From 2cd2fe0828c85c33a6b6ade80a37f331f52a599a Mon Sep 17 00:00:00 2001 From: kipmacsaigoren Date: Wed, 15 Sep 2021 12:15:53 -0500 Subject: [PATCH 001/118] Added git things to make it all a little nicer and synthesis work. --- .gitmodules | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitmodules b/.gitmodules index e69de29bb..65e1e71c9 100644 --- a/.gitmodules +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "sky130/sky130_osu_sc_t12"] + path = sky130/sky130_osu_sc_t12 + url = https://foss-eda-tools.googlesource.com/skywater-pdk/libs/sky130_osu_sc_t12/ From 97c474327c7d9c45b8ae682e3cf7c19ce9cf4f0c Mon Sep 17 00:00:00 2001 From: kipmacsaigoren Date: Wed, 15 Sep 2021 12:24:24 -0500 Subject: [PATCH 002/118] changed priority circuits for synthesis and light cleanup --- wally-pipelined/src/mmu/pmpadrdec.sv | 2 +- wally-pipelined/src/mmu/priorityonehot.sv | 17 ++++++++++------- wally-pipelined/src/mmu/prioritythermometer.sv | 8 ++++++-- 3 files changed, 17 insertions(+), 10 deletions(-) diff --git a/wally-pipelined/src/mmu/pmpadrdec.sv b/wally-pipelined/src/mmu/pmpadrdec.sv index 618167827..9fe28b261 100644 --- a/wally-pipelined/src/mmu/pmpadrdec.sv +++ b/wally-pipelined/src/mmu/pmpadrdec.sv @@ -82,7 +82,7 @@ module pmpadrdec ( assign NAMask[1:0] = {2'b11}; prioritythemometer #(`PA_BITS-2) namaskgen( - .a({PMPAdr[`PA_BITS-4:0], (AdrMode == NAPOT)}), + .a({~PMPAdr[`PA_BITS-4:0], (AdrMode == NAPOT)}), // *** confusing bit bussing to match the logic for the inside of the thermometer. .y(NAMask[`PA_BITS-1:2])); assign NAMatch = &((PhysicalAddress ~^ CurrentAdrFull) | NAMask); diff --git a/wally-pipelined/src/mmu/priorityonehot.sv b/wally-pipelined/src/mmu/priorityonehot.sv index 7a17f8d28..f02f8ccc5 100644 --- a/wally-pipelined/src/mmu/priorityonehot.sv +++ b/wally-pipelined/src/mmu/priorityonehot.sv @@ -40,13 +40,16 @@ module priorityonehot #(parameter ENTRIES = 8) ( logic [ENTRIES-1:0] nolower; // generate thermometer code mask - genvar i; - generate - assign nolower[0] = 1'b1; - for (i=1; i Date: Fri, 17 Sep 2021 12:00:38 -0500 Subject: [PATCH 003/118] added new fun ways of putting inputs into the priority thermometer --- wally-pipelined/src/mmu/pmpadrdec.sv | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/wally-pipelined/src/mmu/pmpadrdec.sv b/wally-pipelined/src/mmu/pmpadrdec.sv index 9fe28b261..46ee6bdcb 100644 --- a/wally-pipelined/src/mmu/pmpadrdec.sv +++ b/wally-pipelined/src/mmu/pmpadrdec.sv @@ -81,8 +81,16 @@ module pmpadrdec ( assign NAMask[1:0] = {2'b11}; +// *** BAD DELETE LATER ADDED for hopefully fixing synth + logic [`PA_BITS-3:0] maskInput; + + assign maskInput = `PA_BITS'd39; // *** added to really just try anything with the inputs of the thermometer. + + // *** maskinput used to be {~PMPAdr[`PA_BITS-4:0], (AdrMode == NAPOT)} +// **** + prioritythemometer #(`PA_BITS-2) namaskgen( - .a({~PMPAdr[`PA_BITS-4:0], (AdrMode == NAPOT)}), // *** confusing bit bussing to match the logic for the inside of the thermometer. + .a(maskInput), // *** confusing bit bussing to match the logic for the inside of the thermometer. .y(NAMask[`PA_BITS-1:2])); assign NAMatch = &((PhysicalAddress ~^ CurrentAdrFull) | NAMask); From 4de4774a71f01f9cda381da13324b8a84eb12456 Mon Sep 17 00:00:00 2001 From: Kip Macsai-Goren Date: Fri, 17 Sep 2021 13:07:21 -0400 Subject: [PATCH 004/118] more input changes on prioirty thermometer. passes lint --- wally-pipelined/src/mmu/pmpadrdec.sv | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wally-pipelined/src/mmu/pmpadrdec.sv b/wally-pipelined/src/mmu/pmpadrdec.sv index 46ee6bdcb..584b18fba 100644 --- a/wally-pipelined/src/mmu/pmpadrdec.sv +++ b/wally-pipelined/src/mmu/pmpadrdec.sv @@ -84,7 +84,7 @@ module pmpadrdec ( // *** BAD DELETE LATER ADDED for hopefully fixing synth logic [`PA_BITS-3:0] maskInput; - assign maskInput = `PA_BITS'd39; // *** added to really just try anything with the inputs of the thermometer. + assign maskInput = 'd39; // *** added to really just try anything with the inputs of the thermometer. // *** maskinput used to be {~PMPAdr[`PA_BITS-4:0], (AdrMode == NAPOT)} // **** From 5bcae393c93b11c83420ba1e05ea51d40c474b3a Mon Sep 17 00:00:00 2001 From: Skylar Litz Date: Mon, 4 Oct 2021 18:23:31 -0400 Subject: [PATCH 005/118] added delayed MIP signal --- wally-pipelined/testbench/testbench-linux.sv | 22 ++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/wally-pipelined/testbench/testbench-linux.sv b/wally-pipelined/testbench/testbench-linux.sv index 76a1841b8..73077e7de 100644 --- a/wally-pipelined/testbench/testbench-linux.sv +++ b/wally-pipelined/testbench/testbench-linux.sv @@ -38,7 +38,7 @@ module testbench(); - parameter waveOnICount = `BUSYBEAR*140000 + `BUILDROOT*8700000; // # of instructions at which to turn on waves in graphical sim + parameter waveOnICount = `BUSYBEAR*140000 + `BUILDROOT*3100000; // # of instructions at which to turn on waves in graphical sim string ProgramAddrMapFile, ProgramLabelMapFile; /////////////////////////////////////////////////////////////////////////////// @@ -137,6 +137,7 @@ module testbench(); integer NumCSRWIndex; integer NumCSRPostWIndex; logic [`XLEN-1:0] InstrCountW; + integer RequestDelayedMIP; // ------ // Macros @@ -246,9 +247,16 @@ module testbench(); MarkerIndex += 2; // match MIP to QEMU's because interrupts are imprecise if(ExpectedCSRArrayM[NumCSRM].substr(0, 2) == "mip") begin - $display("%tns: Updating MIP to %x",$time,ExpectedCSRArrayValueM[NumCSRM]); - MIPexpected = ExpectedCSRArrayValueM[NumCSRM]; - force dut.hart.priv.csr.genblk1.csri.MIP_REGW = MIPexpected; + $display("%tn: ExpectedCSRArrayM[7] (MEPC) = %x",$time,ExpectedCSRArrayM[7]); + $display("%tn: ExpectedPCM = %x",$time,ExpectedPCM); + // if PC does not equal MEPC, request delayed MIP is True + if(ExpectedPCM != ExpectedCSRArrayM[7]) begin + RequestDelayedMIP = 1; + end else begin + $display("%tns: Updating MIP to %x",$time,ExpectedCSRArrayValueM[NumCSRM]); + MIPexpected = ExpectedCSRArrayValueM[NumCSRM]; + force dut.hart.priv.csr.genblk1.csri.MIP_REGW = MIPexpected; + end end NumCSRM++; end @@ -326,6 +334,12 @@ module testbench(); // step2: make all checks in the write back stage. always @(negedge clk) begin + if(RequestDelayedMIP) begin + $display("%tns: Updating MIP to %x",$time,ExpectedCSRArrayValueW[NumCSRM]); + MIPexpected = ExpectedCSRArrayValueW[NumCSRM]; + force dut.hart.priv.csr.genblk1.csri.MIP_REGW = MIPexpected; + RequestDelayedMIP = 0; + end // always check PC, instruction bits if (checkInstrW) begin InstrCountW += 1; From a91c0c8fc714017f25d0aa6a4144e68ee4028efd Mon Sep 17 00:00:00 2001 From: "James E. Stine" Date: Wed, 6 Oct 2021 08:26:09 -0500 Subject: [PATCH 006/118] Make changes to fpdiv - still working on clock issue with fsm that was changed from posedge to negedge - also updated fpdivsqrt rounding to handle testfloat --- wally-pipelined/src/fpu/convert_inputs.sv | 29 +- wally-pipelined/src/fpu/exception_div.sv | 27 +- wally-pipelined/src/fpu/fpdiv.sv | 155 +++--- wally-pipelined/src/fpu/fpu.sv | 613 ++++++++++------------ wally-pipelined/src/fpu/fregfile.sv | 33 +- wally-pipelined/src/fpu/fsm.sv | 146 +++--- wally-pipelined/src/fpu/rounder_div.sv | 109 ++-- wally-pipelined/src/fpu/sbtm_a0.sv | 29 +- wally-pipelined/src/fpu/sbtm_a1.sv | 29 +- wally-pipelined/src/fpu/sbtm_a2.sv | 29 +- wally-pipelined/src/fpu/sbtm_a3.sv | 27 +- wally-pipelined/src/fpu/sbtm_div.sv | 24 + wally-pipelined/src/fpu/sbtm_sqrt.sv | 24 + 13 files changed, 698 insertions(+), 576 deletions(-) diff --git a/wally-pipelined/src/fpu/convert_inputs.sv b/wally-pipelined/src/fpu/convert_inputs.sv index bf56cb006..9a0584baa 100755 --- a/wally-pipelined/src/fpu/convert_inputs.sv +++ b/wally-pipelined/src/fpu/convert_inputs.sv @@ -1,9 +1,26 @@ -// This module takes as inputs two operands (op1 and op2) -// the operation type (op_type) and the result precision (P). -// Based on the operation and precision , it conditionally -// converts single precision values to double precision values -// and modifies the sign of op1. The converted operands are Float1 -// and Float2. +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 8/1/2018 +// +// Purpose: Floating point divider/square root top unit (Goldschmidt) +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// module convert_inputs( input [63:0] op1, // 1st input operand (A) diff --git a/wally-pipelined/src/fpu/exception_div.sv b/wally-pipelined/src/fpu/exception_div.sv index 374320683..3e701d2fb 100755 --- a/wally-pipelined/src/fpu/exception_div.sv +++ b/wally-pipelined/src/fpu/exception_div.sv @@ -23,9 +23,10 @@ module exception_div ( logic BNaN; // '1' if B is a not-a-number logic ASNaN; // '1' if A is a signalling not-a-number logic BSNaN; // '1' if B is a signalling not-a-number - logic ZQNaN; // '1' if result Z is a quiet NaN + logic ZSNaN; // '1' if result Z is a quiet NaN logic ZInf; // '1' if result Z is an infnity - logic Zero; // '1' if result is zero + logic Zero; // '1' if result is zero + logic NegSqrt; // '1' if sqrt and operand is negative //***take this module out and add more registers or just recalculate it all // Determine if mantissas are all zeros @@ -48,32 +49,34 @@ module exception_div ( assign AZero = AzeroE & AzeroM; assign BZero = BzeroE & BzeroE; + // Is NaN if operand is negative and its a sqrt + assign NegSqrt = (A[63] & op_type & ~AZero); + // An "Invalid Operation" exception occurs if (A or B is a signalling NaN) // or (A and B are both Infinite) assign Invalid = ASNaN | BSNaN | (((AInf & BInf) | (AZero & BZero))&~op_type) | - (A[63] & op_type); - + NegSqrt; // The result is a quiet NaN if (an "Invalid Operation" exception occurs) // or (A is a NaN) or (B is a NaN). - assign ZQNaN = Invalid | ANaN | BNaN; + assign ZSNaN = Invalid | ANaN | BNaN; // The result is zero assign Zero = (AZero | BInf)&~op_type | AZero&op_type; // The result is +Inf if ((A is Inf) or (B is 0)) and (the // result is not a quiet NaN). - assign ZInf = (AInf | BZero)&~ZQNaN&~op_type | AInf&op_type&~ZQNaN; + assign ZInf = (AInf | BZero)&~ZSNaN&~op_type | AInf&op_type&~ZSNaN; // Set the type of the result as follows: // Ztype Result // 000 Normal - // 001 Quiet NaN // 010 Infinity // 011 Zero - // 110 DivZero - assign Ztype[0] = ZQNaN | Zero; - assign Ztype[1] = ZInf | Zero; - assign Ztype[2] = BZero&~op_type; - + // 110 Div by 0 + // 111 SNaN + assign Ztype[2] = (ZSNaN); + assign Ztype[1] = (ZSNaN) | (Zero) | (ZInf); + assign Ztype[0] = (ZSNaN) | (Zero); + endmodule // exception diff --git a/wally-pipelined/src/fpu/fpdiv.sv b/wally-pipelined/src/fpu/fpdiv.sv index a2534149f..0a937b5b0 100755 --- a/wally-pipelined/src/fpu/fpdiv.sv +++ b/wally-pipelined/src/fpu/fpdiv.sv @@ -1,92 +1,86 @@ +/////////////////////////////////////////// // -// File name : fpdiv -// Title : Floating-Point Divider/Square-Root -// project : FPU -// Library : fpdiv -// Author(s) : James E. Stine, Jr. -// Purpose : definition of main unit to floating-point div/sqrt -// notes : +// Written: James Stine +// Modified: 8/1/2018 // -// Copyright Oklahoma State University +// Purpose: Floating point divider/square root top unit (Goldschmidt) +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University // -// Basic Operations +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: // -// Step 1: Load operands, set flags, and convert SP to DP -// Step 2: Check for special inputs ( +/- Infinity, NaN) -// Step 3: Exponent Logic -// Step 4: Divide/Sqrt using Goldschmidt -// Step 5: Normalize the result.// -// Shift left until normalized. Normalized when the value to the -// left of the binrary point is 1. -// Step 6: Round the result.// -// Step 7: Put quotient/remainder onto output. +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. // +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// // `timescale 1ps/1ps module fpdiv ( - input logic clk, - input logic reset, - input logic start, - input logic [63:0] op1, // 1st input operand (A) - input logic [63:0] op2, // 2nd input operand (B) - input logic [1:0] rm, // Rounding mode - specify values - input logic op_type, // Function opcode - input logic P, // Result Precision (0 for double, 1 for single) - input logic OvEn, // Overflow trap enabled - input logic UnEn, // Underflow trap enabled - output logic done, - output logic FDivBusyE, - output logic [63:0] AS_Result, // Result of operation - output logic [4:0] Flags); // IEEE exception flags + input logic clk, + input logic reset, + input logic start, + input logic [63:0] op1, + input logic [63:0] op2, + input logic [1:0] rm, + input logic op_type, + input logic P, + input logic OvEn, + input logic UnEn, + input logic XNaNQ, + input logic YNaNQ, + input logic XZeroQ, + input logic YZeroQ, + input logic XInfQ, + input logic YInfQ, - - logic [63:0] Float1; - logic [63:0] Float2; + output logic done, + output logic FDivBusyE, + output logic [63:0] AS_Result, + output logic [4:0] Flags); - logic [12:0] exp1, exp2, expF; - logic [12:0] exp_diff, bias; - logic [13:0] exp_sqrt; - logic [12:0] exp_s; - logic [12:0] exp_c; + logic [63:0] Float1; + logic [63:0] Float2; - logic [10:0] exponent; - logic [63:0] Result; - logic [52:0] mantissaA; - logic [52:0] mantissaB; + logic [12:0] exp1, exp2, expF; + logic [12:0] exp_diff, bias; + logic [13:0] exp_sqrt; + logic [63:0] Result; + logic [52:0] mantissaA; + logic [52:0] mantissaB; - logic [2:0] sel_inv; - logic Invalid; - logic [4:0] FlagsIn; + logic [2:0] sel_inv; + logic Invalid; + logic [4:0] FlagsIn; logic signResult; logic convert; - logic sub; + logic sub; - logic [63:0] q1, qm1, qp1, q0, qm0, qp0; - logic [63:0] rega_out, regb_out, regc_out, regd_out; - logic [127:0] regr_out; - logic [2:0] sel_muxa, sel_muxb; + logic [63:0] q1, qm1, qp1, q0, qm0, qp0; + logic [63:0] rega_out, regb_out, regc_out, regd_out; + logic [127:0] regr_out; + logic [2:0] sel_muxa, sel_muxb; logic sel_muxr; logic load_rega, load_regb, load_regc, load_regd, load_regr; - - logic load_regs; - logic exp_cout1, exp_cout2; - logic exp_odd, open; - // div/sqrt - // fdiv = 0 - // fsqrt = 1 + logic load_regs; + logic exp_cout1, exp_cout2; + logic exp_odd, open; + + // op_type : fdiv=0, fsqrt=1 assign Float1 = op1; assign Float2 = op_type ? op1 : op2; - - // Test for exceptions and return the "Invalid Operation" and - // "Denormalized" Input Flags. The "sel_inv" is used in - // the third pipeline stage to select the result. Also, op1_Norm - // and op2_Norm are one if op1 and op2 are not zero or denormalized. - // sub is one if the effective operation is subtaction. - exception_div exc1 (.A(Float1), .B(Float2), .op_type, - // output: - .Ztype(sel_inv), .Invalid); - + + // Exception detection + exception_div exc1 (.A(Float1), .B(Float2), .op_type, .Ztype(sel_inv), .Invalid); + // Determine Sign/Mantissa assign signResult = (Float1[63]^Float2[63]); assign mantissaA = {1'b1, Float1[51:0]}; @@ -103,29 +97,30 @@ module fpdiv ( assign {exp_cout2, exp_sqrt} = {1'b0, exp1} + {4'h0, 10'h3ff} + exp_odd; // Choose correct exponent assign expF = op_type ? exp_sqrt[13:1] : exp_diff; - + // Main Goldschmidt/Division Routine divconv goldy (.q1, .qm1, .qp1, .q0, .qm0, .qp0, .rega_out, .regb_out, .regc_out, .regd_out, .regr_out, .d(mantissaB), .n(mantissaA), .sel_muxa, .sel_muxb, .sel_muxr, .reset, .clk, .load_rega, .load_regb, .load_regc, .load_regd, .load_regr, .load_regs, .P, .op_type, .exp_odd); - + // FSM : control divider fsm control (.clk, .reset, .start, .op_type, - // outputs: - .done, .load_rega, .load_regb, .load_regc, .load_regd, - .load_regr, .load_regs, .sel_muxa, .sel_muxb, .sel_muxr, - .divBusy(FDivBusyE)); + .done, .load_rega, .load_regb, .load_regc, .load_regd, + .load_regr, .load_regs, .sel_muxa, .sel_muxb, .sel_muxr, + .divBusy(FDivBusyE)); // Round the mantissa to a 52-bit value, with the leading one // removed. The rounding units also handles special cases and // set the exception flags. rounder_div round1 (.rm, .P, .OvEn, .UnEn, .exp_diff(expF), - .sel_inv, .Invalid, .SignR(signResult), - .q1, .qm1, .qp1, .q0, .qm0, .qp0, .regr_out, - // outputs: - .Result, .Flags(FlagsIn)); - + .sel_inv, .Invalid, .SignR(signResult), + .Float1(op1), .Float2(op2), + .XNaNQ, .YNaNQ, .XZeroQ, .YZeroQ, + .XInfQ, .YInfQ, .op_type, + .q1, .qm1, .qp1, .q0, .qm0, .qp0, .regr_out, + .Result, .Flags(FlagsIn)); + // Store the final result and the exception flags in registers. flopenr #(64) rega (clk, reset, done, Result, AS_Result); flopenr #(5) regc (clk, reset, done, FlagsIn, Flags); diff --git a/wally-pipelined/src/fpu/fpu.sv b/wally-pipelined/src/fpu/fpu.sv index cadfafae0..34aa3edd3 100755 --- a/wally-pipelined/src/fpu/fpu.sv +++ b/wally-pipelined/src/fpu/fpu.sv @@ -1,6 +1,6 @@ /////////////////////////////////////////// // -// Written: Katherine Parry, Bret Mathis +// Written: Katherine Parry, James Stine, Brett Mathis // Modified: 6/23/2021 // // Purpose: FPU @@ -25,24 +25,24 @@ `include "wally-config.vh" module fpu ( - input logic clk, - input logic reset, - input logic [2:0] FRM_REGW, // Rounding mode from CSR - input logic [31:0] InstrD, // instruction from IFU - input logic [`XLEN-1:0] ReadDataW,// Read data from memory - input logic [`XLEN-1:0] SrcAE, // Integer input being processed (from IEU) - input logic [`XLEN-1:0] SrcAM, // Integer input being written into fpreg (from IEU) - input logic StallE, StallM, StallW, // stall signals from HZU - input logic FlushE, FlushM, FlushW, // flush signals from HZU - input logic [4:0] RdE, RdM, RdW, // which FP register to write to (from IEU) - output logic FRegWriteM, // FP register write enable - output logic FStallD, // Stall the decode stage - output logic FWriteIntE, FWriteIntM, FWriteIntW, // integer register write enable - output logic [`XLEN-1:0] FWriteDataE, // Data to be written to memory - output logic [`XLEN-1:0] FIntResM, // data to be written to integer register - output logic FDivBusyE, // Is the divide/sqrt unit busy (stall execute stage) - output logic IllegalFPUInstrD, // Is the instruction an illegal fpu instruction - output logic [4:0] SetFflagsM // FMA flags (to privileged unit) + input logic clk, + input logic reset, + input logic [2:0] FRM_REGW, // Rounding mode from CSR + input logic [31:0] InstrD, // instruction from IFU + input logic [`XLEN-1:0] ReadDataW,// Read data from memory + input logic [`XLEN-1:0] SrcAE, // Integer input being processed (from IEU) + input logic [`XLEN-1:0] SrcAM, // Integer input being written into fpreg (from IEU) + input logic StallE, StallM, StallW, // stall signals from HZU + input logic FlushE, FlushM, FlushW, // flush signals from HZU + input logic [4:0] RdE, RdM, RdW, // which FP register to write to (from IEU) + output logic FRegWriteM, // FP register write enable + output logic FStallD, // Stall the decode stage + output logic FWriteIntE, FWriteIntM, FWriteIntW, // integer register write enable + output logic [`XLEN-1:0] FWriteDataE, // Data to be written to memory + output logic [`XLEN-1:0] FIntResM, // data to be written to integer register + output logic FDivBusyE, // Is the divide/sqrt unit busy (stall execute stage) + output logic IllegalFPUInstrD, // Is the instruction an illegal fpu instruction + output logic [4:0] SetFflagsM // FMA flags (to privileged unit) ); //*** make everything FLEN at some point @@ -59,338 +59,257 @@ module fpu ( generate if (`F_SUPPORTED | `D_SUPPORTED) begin : fpu - // control signals - logic FRegWriteD, FRegWriteE, FRegWriteW; // FP register write enable - logic [2:0] FrmD, FrmE, FrmM; // FP rounding mode - logic FmtD, FmtE, FmtM, FmtW; // FP precision 0-single 1-double - logic FDivStartD, FDivStartE; // Start division or squareroot - logic FWriteIntD; // Write to integer register - logic [1:0] FForwardXE, FForwardYE, FForwardZE; // forwarding mux control signals - logic [1:0] FResultSelD, FResultSelE, FResultSelM, FResultSelW; // Select the result written to FP register - logic [2:0] FOpCtrlD, FOpCtrlE, FOpCtrlM; // Select which opperation to do in each component - logic [2:0] FResSelD, FResSelE, FResSelM; // Select one of the results that finish in the memory stage - logic [1:0] FIntResSelD, FIntResSelE, FIntResSelM; // Select the result written to the integer resister - logic [4:0] Adr1E, Adr2E, Adr3E; // adresses of each input + // control signals + logic FRegWriteD, FRegWriteE, FRegWriteW; // FP register write enable + logic [2:0] FrmD, FrmE, FrmM; // FP rounding mode + logic FmtD, FmtE, FmtM, FmtW; // FP precision 0-single 1-double + logic FDivStartD, FDivStartE; // Start division or squareroot + logic FWriteIntD; // Write to integer register + logic [1:0] FForwardXE, FForwardYE, FForwardZE; // forwarding mux control signals + logic [1:0] FResultSelD, FResultSelE, FResultSelM, FResultSelW; // Select the result written to FP register + logic [2:0] FOpCtrlD, FOpCtrlE, FOpCtrlM; // Select which opperation to do in each component + logic [2:0] FResSelD, FResSelE, FResSelM; // Select one of the results that finish in the memory stage + logic [1:0] FIntResSelD, FIntResSelE, FIntResSelM; // Select the result written to the integer resister + logic [4:0] Adr1E, Adr2E, Adr3E; // adresses of each input + + // regfile signals + logic [63:0] FRD1D, FRD2D, FRD3D; // Read Data from FP register - decode stage + logic [63:0] FRD1E, FRD2E, FRD3E; // Read Data from FP register - execute stage + logic [63:0] FSrcXE, FSrcXM; // Input 1 to the various units (after forwarding) + logic [63:0] FPreSrcYE, FSrcYE; // Input 2 to the various units (after forwarding) + logic [63:0] FPreSrcZE, FSrcZE; // Input 3 to the various units (after forwarding) + + // unpacking signals + logic XSgnE, YSgnE, ZSgnE; // input's sign - execute stage + logic XSgnM, YSgnM; // input's sign - memory stage + logic [10:0] XExpE, YExpE, ZExpE; // input's exponent - execute stage + logic [10:0] XExpM, YExpM, ZExpM; // input's exponent - memory stage + logic [52:0] XManE, YManE, ZManE; // input's fraction - execute stage + logic [52:0] XManM, YManM, ZManM; // input's fraction - memory stage + logic [10:0] BiasE; // bias based on precision (single=7f double=3ff - max expoent/2) + logic XNaNE, YNaNE, ZNaNE; // is the input a NaN - execute stage + logic XNaNM, YNaNM, ZNaNM; // is the input a NaN - memory stage + logic XSNaNE, YSNaNE, ZSNaNE; // is the input a signaling NaN - execute stage + logic XSNaNM, YSNaNM, ZSNaNM; // is the input a signaling NaN - memory stage + logic XDenormE, YDenormE, ZDenormE; // is the input denormalized + logic XZeroE, YZeroE, ZZeroE; // is the input zero - execute stage + logic XZeroM, YZeroM, ZZeroM; // is the input zero - memory stage + logic XInfE, YInfE, ZInfE; // is the input infinity - execute stage + logic XInfM, YInfM, ZInfM; // is the input infinity - memory stage + logic XExpMaxE; // is the exponent all ones (max value) + logic XNormE; // is normal + + // result and flag signals + logic [63:0] FDivResM, FDivResW; // divide/squareroot result + logic [4:0] FDivFlgM, FDivFlgW; // divide/squareroot flags + logic [63:0] FMAResM, FMAResW; // FMA/multiply result + logic [4:0] FMAFlgM, FMAFlgW; // FMA/multiply result + logic [63:0] ReadResW; // read result (load instruction) + logic [63:0] CvtFpResE, CvtFpResM, CvtFpResW; // add/FP -> FP convert result + logic [4:0] CvtFpFlgE, CvtFpFlgM, CvtFpFlgW; // add/FP -> FP convert flags + logic [63:0] CvtResE, CvtResM; // FP <-> int convert result + logic [4:0] CvtFlgE, CvtFlgM; // FP <-> int convert flags //*** trim this + logic [63:0] ClassResE, ClassResM; // classify result + logic [63:0] CmpResE, CmpResM; // compare result + logic CmpNVE, CmpNVM; // compare invalid flag (Not Valid) + logic [63:0] SgnResE, SgnResM; // sign injection result + logic SgnNVE, SgnNVM; // sign injection invalid flag (Not Valid) + logic [63:0] FResE, FResM, FResW; // selected result that is ready in the memory stage + logic [4:0] FFlgE, FFlgM; // selected flag that is ready in the memory stage + logic [`XLEN-1:0] FIntResE; + logic [63:0] FPUResultW; // final FP result being written to the FP register + + // other signals + logic FDivSqrtDoneE; // is divide done + logic [63:0] DivInput1E, DivInput2E; // inputs to divide/squareroot unit + logic FDivClk; // clock for divide/squareroot unit + logic [63:0] AlignedSrcAE; // align SrcA to the floating point format + + // DECODE STAGE + // calculate FP control signals + fctrl fctrl (.Funct7D(InstrD[31:25]), .OpD(InstrD[6:0]), .Rs2D(InstrD[24:20]), .Funct3D(InstrD[14:12]), .FRM_REGW, + .IllegalFPUInstrD, .FRegWriteD, .FDivStartD, .FResultSelD, .FOpCtrlD, .FResSelD, + .FIntResSelD, .FmtD, .FrmD, .FWriteIntD); - // regfile signals - logic [63:0] FRD1D, FRD2D, FRD3D; // Read Data from FP register - decode stage - logic [63:0] FRD1E, FRD2E, FRD3E; // Read Data from FP register - execute stage - logic [63:0] FSrcXE, FSrcXM; // Input 1 to the various units (after forwarding) - logic [63:0] FPreSrcYE, FSrcYE; // Input 2 to the various units (after forwarding) - logic [63:0] FPreSrcZE, FSrcZE; // Input 3 to the various units (after forwarding) - - // unpacking signals - logic XSgnE, YSgnE, ZSgnE; // input's sign - execute stage - logic XSgnM, YSgnM; // input's sign - memory stage - logic [10:0] XExpE, YExpE, ZExpE; // input's exponent - execute stage - logic [10:0] XExpM, YExpM, ZExpM; // input's exponent - memory stage - logic [52:0] XManE, YManE, ZManE; // input's fraction - execute stage - logic [52:0] XManM, YManM, ZManM; // input's fraction - memory stage - logic [10:0] BiasE; // bias based on precision (single=7f double=3ff - max expoent/2) - logic XNaNE, YNaNE, ZNaNE; // is the input a NaN - execute stage - logic XNaNM, YNaNM, ZNaNM; // is the input a NaN - memory stage - logic XSNaNE, YSNaNE, ZSNaNE; // is the input a signaling NaN - execute stage - logic XSNaNM, YSNaNM, ZSNaNM; // is the input a signaling NaN - memory stage - logic XDenormE, YDenormE, ZDenormE; // is the input denormalized - logic XZeroE, YZeroE, ZZeroE; // is the input zero - execute stage - logic XZeroM, YZeroM, ZZeroM; // is the input zero - memory stage - logic XInfE, YInfE, ZInfE; // is the input infinity - execute stage - logic XInfM, YInfM, ZInfM; // is the input infinity - memory stage - logic XExpMaxE; // is the exponent all ones (max value) - logic XNormE; // is normal - - - // result and flag signals - logic [63:0] FDivResM, FDivResW; // divide/squareroot result - logic [4:0] FDivFlgM, FDivFlgW; // divide/squareroot flags + // FP register file + // - can read 3 registers and write 1 register every cycle + fregfile fregfile (.clk, .reset, .we4(FRegWriteW), + .a1(InstrD[19:15]), .a2(InstrD[24:20]), .a3(InstrD[31:27]), .a4(RdW), + .wd4(FPUResultW), + .rd1(FRD1D), .rd2(FRD2D), .rd3(FRD3D)); + + // D/E pipeline registers + flopenrc #(64) DEReg1(clk, reset, FlushE, ~StallE, FRD1D, FRD1E); + flopenrc #(64) DEReg2(clk, reset, FlushE, ~StallE, FRD2D, FRD2E); + flopenrc #(64) DEReg3(clk, reset, FlushE, ~StallE, FRD3D, FRD3E); + flopenrc #(15) DEAdrReg(clk, reset, FlushE, ~StallE, {InstrD[19:15], InstrD[24:20], InstrD[31:27]}, + {Adr1E, Adr2E, Adr3E}); + flopenrc #(17) DECtrlReg3(clk, reset, FlushE, ~StallE, + {FRegWriteD, FResultSelD, FResSelD, FIntResSelD, FrmD, FmtD, FOpCtrlD, FWriteIntD, FDivStartD}, + {FRegWriteE, FResultSelE, FResSelE, FIntResSelE, FrmE, FmtE, FOpCtrlE, FWriteIntE, FDivStartE}); + + // EXECUTION STAGE + // Hazard unit for FPU + // - determines if any forwarding or stalls are needed + fhazard fhazard(.Adr1E, .Adr2E, .Adr3E, .FRegWriteM, .FRegWriteW, .RdM, .RdW, .FResultSelM, + .FStallD, .FForwardXE, .FForwardYE, .FForwardZE); + + // forwarding muxs + mux3 #(64) fxemux(FRD1E, FPUResultW, FResM, FForwardXE, FSrcXE); + mux3 #(64) fyemux(FRD2E, FPUResultW, FResM, FForwardYE, FPreSrcYE); + mux3 #(64) fzemux(FRD3E, FPUResultW, FResM, FForwardZE, FPreSrcZE); + mux3 #(64) fyaddmux(FPreSrcYE, {{32{1'b1}}, 2'b0, {7{1'b1}}, 23'b0}, + {2'b0, {10{1'b1}}, 52'b0}, + {FmtE&FOpCtrlE[2]&FOpCtrlE[1]&(FResultSelE==3'b01), ~FmtE&FOpCtrlE[2]&FOpCtrlE[1]&(FResultSelE==3'b01)}, + FSrcYE); // Force Z to be 0 for multiply instructions + // Force Z to be 0 for multiply instructions + mux3 #(64) fzmulmux(FPreSrcZE, 64'b0, FPreSrcYE, {FOpCtrlE[2]&FOpCtrlE[1], FOpCtrlE[2]&~FOpCtrlE[1]}, FSrcZE); + + // unpacking unit + // - splits FP inputs into their various parts + // - does some classifications (SNaN, NaN, Denorm, Norm, Zero, Infifnity) + unpacking unpacking(.X(FSrcXE), .Y(FSrcYE), .Z(FSrcZE), .FOpCtrlE, .FmtE, + .XSgnE, .YSgnE, .ZSgnE, .XExpE, .YExpE, .ZExpE, .XManE, .YManE, .ZManE, + .XNaNE, .YNaNE, .ZNaNE, .XSNaNE, .YSNaNE, .ZSNaNE, .XDenormE, .YDenormE, .ZDenormE, + .XZeroE, .YZeroE, .ZZeroE, .BiasE, .XInfE, .YInfE, .ZInfE, .XExpMaxE, .XNormE); + + // FMA + // - two stage FMA + // - execute stage - multiplication and addend shifting + // - memory stage - addition and rounding + // - handles FMA and multiply instructions + fma fma (.clk, .reset, .FlushM, .StallM, + .XSgnE, .YSgnE, .ZSgnE, .XExpE, .YExpE, .ZExpE, .XManE, .YManE, .ZManE, + .XDenormE, .YDenormE, .ZDenormE, .XZeroE, .YZeroE, .ZZeroE, .BiasE, + .XSgnM, .YSgnM, .XExpM, .YExpM, .ZExpM, .XManM, .YManM, .ZManM, + .XNaNM, .YNaNM, .ZNaNM, .XZeroM, .YZeroM, .ZZeroM, + .XInfM, .YInfM, .ZInfM, .XSNaNM, .YSNaNM, .ZSNaNM, + .FOpCtrlE, + .FmtE, .FmtM, .FrmM, + .FMAFlgM, .FMAResM); + + // clock gater + // - creates a clock that only runs durring divide/sqrt instructions + // - using the seperate clock gives the divide/sqrt unit some to get set up + // *** the module says not to use in synthisis + clockgater fpdivclkg(.E(FDivStartE), + .SE(1'b0), + .CLK(clk), + .ECLK(FDivClk)); + + // capture the inputs for divide/sqrt + // - if not captured any forwarded inputs will change durring computation + // - this problem is caused by stalling the execute stage + // - the other units don't have this problem, only div/sqrt stalls the execute stage + flopenrc #(64) reg_input1 (.d({XSgnE, XExpE, XManE[51:0]}), .q(DivInput1E), + .en(1'b1), .clear(FDivSqrtDoneE), + .reset(reset), .clk(FDivBusyE)); + flopenrc #(64) reg_input2 (.d({YSgnE, YExpE, YManE[51:0]}), .q(DivInput2E), + .en(1'b1), .clear(FDivSqrtDoneE), + .reset(reset), .clk(FDivBusyE)); + flopenrc #(6) reg_input3 (.d({XNaNE, YNaNE, XInfE, YInfE, XZeroE, YZeroE}), + .q({XNaNQ, YNaNQ, XInfQ, YInfQ, XZeroQ, YZeroQ}), + .en(1'b1), .clear(FDivSqrtDoneE), + .reset(reset), .clk(FDivBusyE)); + + // fpdivsqrt using Goldschmidt's iteration + fpdiv fdivsqrt (.op1(DivInput1E), .op2(DivInput2E), .rm(FrmE[1:0]), .op_type(FOpCtrlE[0]), + .reset, .clk(FDivClk), .start(FDivStartE), .P(~FmtE), .OvEn(1'b1), .UnEn(1'b1), + .XNaNQ, .YNaNQ, .XInfQ, .YInfQ, .XZeroQ, .YZeroQ, + .FDivBusyE, .done(FDivSqrtDoneE), .AS_Result(FDivResM), .Flags(FDivFlgM)); + + // convert from signle to double and vice versa + cvtfp cvtfp (.XExpE, .XManE, .XSgnE, .XZeroE, .XDenormE, .XInfE, .XNaNE, .XSNaNE, .FrmE, .FmtE, .CvtFpResE, .CvtFpFlgE); + + // compare unit + // - computation is done in one stage + // - writes to FP file durring min/max instructions + // - other comparisons write a 1 or 0 to the integer register + fcmp fcmp (.op1({XSgnE,XExpE,XManE[`NF-1:0]}), .op2({YSgnE,YExpE,YManE[`NF-1:0]}), + .FSrcXE, .FSrcYE, .FOpCtrlE, + .FmtE, .XNaNE, .YNaNE, .XZeroE, .YZeroE, + .Invalid(CmpNVE), .CmpResE); + + // sign injection unit + // - computation is done in one stage + fsgn fsgn (.SgnOpCodeE(FOpCtrlE[1:0]), .XSgnE, .YSgnE, .FSrcXE, .FmtE, .XExpMaxE, + .SgnNVE, .SgnResE); + + // classify + // - computation is done in one stage + // - most of the work is done in the unpacking unit + // - result is written to the integer register + fclassify fclassify (.XSgnE, .XDenormE, .XZeroE, .XNaNE, .XInfE, .XNormE, + .XSNaNE, .ClassResE); + + fcvt fcvt (.XSgnE, .XExpE, .XManE, .XZeroE, .XNaNE, .XInfE, .XDenormE, .BiasE, .SrcAE, .FOpCtrlE, .FmtE, .FrmE, + .CvtResE, .CvtFlgE); + + // data to be stored in memory - to IEU + // - FP uses NaN-blocking format + // - if there are any unsused bits the most significant bits are filled with 1s + assign FWriteDataE = FSrcYE[`XLEN-1:0]; + + // Align SrcA to MSB when single precicion + mux2 #(64) SrcAMux({{32{1'b1}}, SrcAE[31:0]}, {{64-`XLEN{1'b1}}, SrcAE}, FmtE, AlignedSrcAE); + + // select a result that may be written to the FP register + mux5 #(64) FResMux(AlignedSrcAE, SgnResE, CmpResE, CvtResE, CvtFpResE, FResSelE, FResE); + mux5 #(5) FFlgMux(5'b0, {4'b0, SgnNVE}, {4'b0, CmpNVE}, CvtFlgE, CvtFpFlgE, FResSelE, FFlgE); + + // select the result that may be written to the integer register - to IEU + mux4 #(`XLEN) IntResMux(CmpResE[`XLEN-1:0], FSrcXE[`XLEN-1:0], ClassResE[`XLEN-1:0], + CvtResE[`XLEN-1:0], FIntResSelE, FIntResE); + + // E/M pipe registers + + // flopenrc #(64) EMFpReg1(clk, reset, FlushM, ~StallM, FSrcXE, FSrcXM); + flopenrc #(65) EMFpReg2(clk, reset, FlushM, ~StallM, {XSgnE,XExpE,XManE}, {XSgnM,XExpM,XManM}); + flopenrc #(65) EMFpReg3(clk, reset, FlushM, ~StallM, {YSgnE,YExpE,YManE}, {YSgnM,YExpM,YManM}); + flopenrc #(64) EMFpReg4(clk, reset, FlushM, ~StallM, {ZExpE,ZManE}, {ZExpM,ZManM}); + flopenrc #(12) EMFpReg5(clk, reset, FlushM, ~StallM, + {XZeroE, YZeroE, ZZeroE, XInfE, YInfE, ZInfE, XNaNE, YNaNE, ZNaNE, XSNaNE, YSNaNE, ZSNaNE}, + {XZeroM, YZeroM, ZZeroM, XInfM, YInfM, ZInfM, XNaNM, YNaNM, ZNaNM, XSNaNM, YSNaNM, ZSNaNM}); + flopenrc #(64) EMRegCmpRes(clk, reset, FlushM, ~StallM, FResE, FResM); + flopenrc #(5) EMRegCmpFlg(clk, reset, FlushM, ~StallM, FFlgE, FFlgM); + flopenrc #(`XLEN) EMRegSgnRes(clk, reset, FlushM, ~StallM, FIntResE, FIntResM); + flopenrc #(11) EMCtrlReg(clk, reset, FlushM, ~StallM, + {FRegWriteE, FResultSelE, FrmE, FmtE, FOpCtrlE, FWriteIntE}, + {FRegWriteM, FResultSelM, FrmM, FmtM, FOpCtrlM, FWriteIntM}); + + // BEGIN MEMORY STAGE + // FPU flag selection - to privileged + mux4 #(5) FPUFlgMux(5'b0, FMAFlgM, FDivFlgM, FFlgM, FResultSelW, SetFflagsM); - logic [63:0] FMAResM, FMAResW; // FMA/multiply result - logic [4:0] FMAFlgM, FMAFlgW; // FMA/multiply result - - logic [63:0] ReadResW; // read result (load instruction) + // M/W pipe registers + flopenrc #(64) MWRegFma(clk, reset, FlushW, ~StallW, FMAResM, FMAResW); + flopenrc #(64) MWRegDiv(clk, reset, FlushW, ~StallW, FDivResM, FDivResW); + flopenrc #(64) MWRegAdd(clk, reset, FlushW, ~StallW, CvtFpResM, CvtFpResW); + flopenrc #(64) MWRegClass(clk, reset, FlushW, ~StallW, FResM, FResW); + flopenrc #(5) MWCtrlReg(clk, reset, FlushW, ~StallW, + {FRegWriteM, FResultSelM, FmtM, FWriteIntM}, + {FRegWriteW, FResultSelW, FmtW, FWriteIntW}); + + // BEGIN WRITEBACK STAGE + + // put ReadData into NaN-blocking format + // - if there are any unsused bits the most significant bits are filled with 1s + // - for load instruction + mux2 #(64) ReadResMux({{32{1'b1}}, ReadDataW[31:0]}, {{64-`XLEN{1'b1}}, ReadDataW}, FmtW, ReadResW); + + // select the result to be written to the FP register + mux4 #(64) FPUResultMux(ReadResW, FMAResW, FDivResW, FResW, FResultSelW, FPUResultW); - logic [63:0] CvtFpResE, CvtFpResM, CvtFpResW; // add/FP -> FP convert result - logic [4:0] CvtFpFlgE, CvtFpFlgM, CvtFpFlgW; // add/FP -> FP convert flags - - logic [63:0] CvtResE, CvtResM; // FP <-> int convert result - logic [4:0] CvtFlgE, CvtFlgM; // FP <-> int convert flags //*** trim this - - logic [63:0] ClassResE, ClassResM; // classify result - - logic [63:0] CmpResE, CmpResM; // compare result - logic CmpNVE, CmpNVM; // compare invalid flag (Not Valid) - - logic [63:0] SgnResE, SgnResM; // sign injection result - logic SgnNVE, SgnNVM; // sign injection invalid flag (Not Valid) - - logic [63:0] FResE, FResM, FResW; // selected result that is ready in the memory stage - logic [4:0] FFlgE, FFlgM; // selected flag that is ready in the memory stage - - logic [`XLEN-1:0] FIntResE; - - logic [63:0] FPUResultW; // final FP result being written to the FP register - - // other signals - logic FDivSqrtDoneE; // is divide done - logic [63:0] DivInput1E, DivInput2E; // inputs to divide/squareroot unit - logic FDivClk; // clock for divide/squareroot unit - logic [63:0] AlignedSrcAE; // align SrcA to the floating point format - - - - - - //////////////////////////////////////////////////////////////////////////////////////// - //DECODE STAGE - //////////////////////////////////////////////////////////////////////////////////////// - - - - // calculate FP control signals - fctrl fctrl (.Funct7D(InstrD[31:25]), .OpD(InstrD[6:0]), .Rs2D(InstrD[24:20]), .Funct3D(InstrD[14:12]), .FRM_REGW, - // outputs: - .IllegalFPUInstrD, .FRegWriteD, .FDivStartD, .FResultSelD, .FOpCtrlD, .FResSelD, - .FIntResSelD, .FmtD, .FrmD, .FWriteIntD); - - // FP register file - // - can read 3 registers and write 1 register every cycle - fregfile fregfile (.clk, .reset, .we4(FRegWriteW), - .a1(InstrD[19:15]), .a2(InstrD[24:20]), .a3(InstrD[31:27]), .a4(RdW), - .wd4(FPUResultW), - // outputs: - .rd1(FRD1D), .rd2(FRD2D), .rd3(FRD3D)); - - - - - - //////////////////////////////////////////////////////////////////////////////////////// - // D/E pipeline registers - //////////////////////////////////////////////////////////////////////////////////////// - - flopenrc #(64) DEReg1(clk, reset, FlushE, ~StallE, FRD1D, FRD1E); - flopenrc #(64) DEReg2(clk, reset, FlushE, ~StallE, FRD2D, FRD2E); - flopenrc #(64) DEReg3(clk, reset, FlushE, ~StallE, FRD3D, FRD3E); - flopenrc #(15) DEAdrReg(clk, reset, FlushE, ~StallE, {InstrD[19:15], InstrD[24:20], InstrD[31:27]}, - {Adr1E, Adr2E, Adr3E}); - flopenrc #(17) DECtrlReg3(clk, reset, FlushE, ~StallE, - {FRegWriteD, FResultSelD, FResSelD, FIntResSelD, FrmD, FmtD, FOpCtrlD, FWriteIntD, FDivStartD}, - {FRegWriteE, FResultSelE, FResSelE, FIntResSelE, FrmE, FmtE, FOpCtrlE, FWriteIntE, FDivStartE}); - - - - - - - - //////////////////////////////////////////////////////////////////////////////////////// - //EXECUTION STAGE - //////////////////////////////////////////////////////////////////////////////////////// - - - // Hazard unit for FPU - // - determines if any forwarding or stalls are needed - fhazard fhazard(.Adr1E, .Adr2E, .Adr3E, .FRegWriteM, .FRegWriteW, .RdM, .RdW, .FResultSelM, - // outputs: - .FStallD, .FForwardXE, .FForwardYE, .FForwardZE); - - - // forwarding muxs - mux3 #(64) fxemux(FRD1E, FPUResultW, FResM, FForwardXE, FSrcXE); - mux3 #(64) fyemux(FRD2E, FPUResultW, FResM, FForwardYE, FPreSrcYE); - mux3 #(64) fzemux(FRD3E, FPUResultW, FResM, FForwardZE, FPreSrcZE); - mux3 #(64) fyaddmux(FPreSrcYE, {{32{1'b1}}, 2'b0, {7{1'b1}}, 23'b0}, {2'b0, {10{1'b1}}, 52'b0}, {FmtE&FOpCtrlE[2]&FOpCtrlE[1]&(FResultSelE==3'b01), ~FmtE&FOpCtrlE[2]&FOpCtrlE[1]&(FResultSelE==3'b01)}, FSrcYE); // Force Z to be 0 for multiply instructions - mux3 #(64) fzmulmux(FPreSrcZE, 64'b0, FPreSrcYE, {FOpCtrlE[2]&FOpCtrlE[1], FOpCtrlE[2]&~FOpCtrlE[1]}, FSrcZE); // Force Z to be 0 for multiply instructions - - - // unpacking unit - // - splits FP inputs into their various parts - // - does some classifications (SNaN, NaN, Denorm, Norm, Zero, Infifnity) - unpacking unpacking(.X(FSrcXE), .Y(FSrcYE), .Z(FSrcZE), .FOpCtrlE, .FmtE, - // outputs: - .XSgnE, .YSgnE, .ZSgnE, .XExpE, .YExpE, .ZExpE, .XManE, .YManE, .ZManE, - .XNaNE, .YNaNE, .ZNaNE, .XSNaNE, .YSNaNE, .ZSNaNE, .XDenormE, .YDenormE, .ZDenormE, - .XZeroE, .YZeroE, .ZZeroE, .BiasE, .XInfE, .YInfE, .ZInfE, .XExpMaxE, .XNormE); - - // FMA - // - two stage FMA - // - execute stage - multiplication and addend shifting - // - memory stage - addition and rounding - // - handles FMA and multiply instructions - // - contains some E/M pipleine registers - // *** currently handles FLEN and 32 bits(dont know if 32 works with 128 - easy to fix) - change to handle only the supported formats - fma fma (.clk, .reset, .FlushM, .StallM, - .XSgnE, .YSgnE, .ZSgnE, .XExpE, .YExpE, .ZExpE, .XManE, .YManE, .ZManE, - .XDenormE, .YDenormE, .ZDenormE, .XZeroE, .YZeroE, .ZZeroE, .BiasE, - .XSgnM, .YSgnM, .XExpM, .YExpM, .ZExpM, .XManM, .YManM, .ZManM, - .XNaNM, .YNaNM, .ZNaNM, .XZeroM, .YZeroM, .ZZeroM, - .XInfM, .YInfM, .ZInfM, .XSNaNM, .YSNaNM, .ZSNaNM, - .FOpCtrlE, - .FmtE, .FmtM, .FrmM, - // outputs: - .FMAFlgM, .FMAResM); - - // clock gater - // - creates a clock that only runs durring divide/sqrt instructions - // - using the seperate clock gives the divide/sqrt unit some to get set up - // *** the module says not to use in synthisis - clockgater fpdivclkg(.E(FDivStartE), - .SE(1'b0), - .CLK(clk), - .ECLK(FDivClk)); - - // capture the inputs for divide/sqrt - // - if not captured any forwarded inputs will change durring computation - // - this problem is caused by stalling the execute stage - // - the other units don't have this problem, only div/sqrt stalls the execute stage - flopenrc #(64) reg_input1 (.d({XSgnE, XExpE, XManE[51:0]}), .q(DivInput1E), - .en(1'b1), .clear(FDivSqrtDoneE), - .reset(reset), .clk(FDivBusyE)); - flopenrc #(64) reg_input2 (.d({YSgnE, YExpE, YManE[51:0]}), .q(DivInput2E), - .en(1'b1), .clear(FDivSqrtDoneE), - .reset(reset), .clk(FDivBusyE)); - - // output for store instructions - //*** change to use the unpacking unit if possible - fpdiv fdivsqrt (.op1(DivInput1E), .op2(DivInput2E), .rm(FrmE[1:0]), .op_type(FOpCtrlE[0]), - .reset, .clk(FDivClk), .start(FDivStartE), .P(~FmtE), .OvEn(1'b1), .UnEn(1'b1), - // outputs: - .FDivBusyE, .done(FDivSqrtDoneE), .AS_Result(FDivResM), .Flags(FDivFlgM)); - - // convert from signle to double and vice versa - cvtfp cvtfp (.XExpE, .XManE, .XSgnE, .XZeroE, .XDenormE, .XInfE, .XNaNE, .XSNaNE, .FrmE, .FmtE, .CvtFpResE, .CvtFpFlgE); - - // compare unit - // - computation is done in one stage - // - writes to FP file durring min/max instructions - // - other comparisons write a 1 or 0 to the integer register - fcmp fcmp (.op1({XSgnE,XExpE,XManE[`NF-1:0]}), .op2({YSgnE,YExpE,YManE[`NF-1:0]}), - .FSrcXE, .FSrcYE, .FOpCtrlE, - .FmtE, .XNaNE, .YNaNE, .XZeroE, .YZeroE, - // outputs: - .Invalid(CmpNVE), .CmpResE); - - // sign injection unit - // - computation is done in one stage - fsgn fsgn (.SgnOpCodeE(FOpCtrlE[1:0]), .XSgnE, .YSgnE, .FSrcXE, .FmtE, .XExpMaxE, - // outputs: - .SgnNVE, .SgnResE); - - // classify - // - computation is done in one stage - // - most of the work is done in the unpacking unit - // - result is written to the integer register - fclassify fclassify (.XSgnE, .XDenormE, .XZeroE, .XNaNE, .XInfE, .XNormE, - // outputs: - .XSNaNE, .ClassResE); - - fcvt fcvt (.XSgnE, .XExpE, .XManE, .XZeroE, .XNaNE, .XInfE, .XDenormE, .BiasE, .SrcAE, .FOpCtrlE, .FmtE, .FrmE, - // outputs: - .CvtResE, .CvtFlgE); - - // data to be stored in memory - to IEU - // - FP uses NaN-blocking format - // - if there are any unsused bits the most significant bits are filled with 1s - assign FWriteDataE = FSrcYE[`XLEN-1:0]; - - - // Align SrcA to MSB when single precicion - mux2 #(64) SrcAMux({{32{1'b1}}, SrcAE[31:0]}, {{64-`XLEN{1'b1}}, SrcAE}, FmtE, AlignedSrcAE); - - // select a result that may be written to the FP register - mux5 #(64) FResMux(AlignedSrcAE, SgnResE, CmpResE, CvtResE, CvtFpResE, FResSelE, FResE); - mux5 #(5) FFlgMux(5'b0, {4'b0, SgnNVE}, {4'b0, CmpNVE}, CvtFlgE, CvtFpFlgE, FResSelE, FFlgE); - - // select the result that may be written to the integer register - to IEU - mux4 #(`XLEN) IntResMux(CmpResE[`XLEN-1:0], FSrcXE[`XLEN-1:0], ClassResE[`XLEN-1:0], CvtResE[`XLEN-1:0], FIntResSelE, FIntResE); - - - - //***will synth remove registers of values that are always zero? - //////////////////////////////////////////////////////////////////////////////////////// - // E/M pipe registers - //////////////////////////////////////////////////////////////////////////////////////// - - // flopenrc #(64) EMFpReg1(clk, reset, FlushM, ~StallM, FSrcXE, FSrcXM); - flopenrc #(65) EMFpReg2(clk, reset, FlushM, ~StallM, {XSgnE,XExpE,XManE}, {XSgnM,XExpM,XManM}); - flopenrc #(65) EMFpReg3(clk, reset, FlushM, ~StallM, {YSgnE,YExpE,YManE}, {YSgnM,YExpM,YManM}); - flopenrc #(64) EMFpReg4(clk, reset, FlushM, ~StallM, {ZExpE,ZManE}, {ZExpM,ZManM}); - flopenrc #(12) EMFpReg5(clk, reset, FlushM, ~StallM, - {XZeroE, YZeroE, ZZeroE, XInfE, YInfE, ZInfE, XNaNE, YNaNE, ZNaNE, XSNaNE, YSNaNE, ZSNaNE}, - {XZeroM, YZeroM, ZZeroM, XInfM, YInfM, ZInfM, XNaNM, YNaNM, ZNaNM, XSNaNM, YSNaNM, ZSNaNM}); - - flopenrc #(64) EMRegCmpRes(clk, reset, FlushM, ~StallM, FResE, FResM); - flopenrc #(5) EMRegCmpFlg(clk, reset, FlushM, ~StallM, FFlgE, FFlgM); - - flopenrc #(`XLEN) EMRegSgnRes(clk, reset, FlushM, ~StallM, FIntResE, FIntResM); - // flopenrc #(1) EMRegSgnFlg(clk, reset, FlushM, ~StallM, SgnNVE, SgnNVM); - - //flopenrc #(64) EMRegCvtFpRes(clk, reset, FlushM, ~StallM, CvtFpResE, CvtFpResM); - //flopenrc #(5) EMRegCvtFpFlg(clk, reset, FlushM, ~StallM, CvtFpFlgE, CvtFpFlgM); - - // flopenrc #(64) EMRegCvtRes(clk, reset, FlushM, ~StallM, CvtResE, CvtResM); - // flopenrc #(5) EMRegCvtFlg(clk, reset, FlushM, ~StallM, CvtFlgE, CvtFlgM); - - // flopenrc #(64) EMRegClass(clk, reset, FlushM, ~StallM, ClassResE, ClassResM); - - flopenrc #(11) EMCtrlReg(clk, reset, FlushM, ~StallM, - {FRegWriteE, FResultSelE, FrmE, FmtE, FOpCtrlE, FWriteIntE}, - {FRegWriteM, FResultSelM, FrmM, FmtM, FOpCtrlM, FWriteIntM}); - - - - - - - //////////////////////////////////////////////////////////////////////////////////////// - //BEGIN MEMORY STAGE - //////////////////////////////////////////////////////////////////////////////////////// - - - // FPU flag selection - to privileged - mux4 #(5) FPUFlgMux(5'b0, FMAFlgM, FDivFlgM, FFlgM, FResultSelW, SetFflagsM); - - - - - - //////////////////////////////////////////////////////////////////////////////////////// - // M/W pipe registers - //////////////////////////////////////////////////////////////////////////////////////// - flopenrc #(64) MWRegFma(clk, reset, FlushW, ~StallW, FMAResM, FMAResW); - flopenrc #(64) MWRegDiv(clk, reset, FlushW, ~StallW, FDivResM, FDivResW); - flopenrc #(64) MWRegAdd(clk, reset, FlushW, ~StallW, CvtFpResM, CvtFpResW); - flopenrc #(64) MWRegClass(clk, reset, FlushW, ~StallW, FResM, FResW); - flopenrc #(5) MWCtrlReg(clk, reset, FlushW, ~StallW, - {FRegWriteM, FResultSelM, FmtM, FWriteIntM}, - {FRegWriteW, FResultSelW, FmtW, FWriteIntW}); - - - - - //////////////////////////////////////////////////////////////////////////////////////// - // BEGIN WRITEBACK STAGE - //////////////////////////////////////////////////////////////////////////////////////// - - // put ReadData into NaN-blocking format - // - if there are any unsused bits the most significant bits are filled with 1s - // - for load instruction - mux2 #(64) ReadResMux({{32{1'b1}}, ReadDataW[31:0]}, {{64-`XLEN{1'b1}}, ReadDataW}, FmtW, ReadResW); - - // select the result to be written to the FP register - mux4 #(64) FPUResultMux(ReadResW, FMAResW, FDivResW, FResW, FResultSelW, FPUResultW); - - end else begin // no F_SUPPORTED or D_SUPPORTED; tie outputs low - assign FStallD = 0; - assign FWriteIntE = 0; - assign FWriteIntM = 0; - assign FWriteIntW = 0; - assign FWriteDataE = 0; - assign FIntResM = 0; - assign FDivBusyE = 0; - assign IllegalFPUInstrD = 1; - assign SetFflagsM = 0; + assign FStallD = 0; + assign FWriteIntE = 0; + assign FWriteIntM = 0; + assign FWriteIntW = 0; + assign FWriteDataE = 0; + assign FIntResM = 0; + assign FDivBusyE = 0; + assign IllegalFPUInstrD = 1; + assign SetFflagsM = 0; end endgenerate diff --git a/wally-pipelined/src/fpu/fregfile.sv b/wally-pipelined/src/fpu/fregfile.sv index 4b001bc93..fd8e0f608 100644 --- a/wally-pipelined/src/fpu/fregfile.sv +++ b/wally-pipelined/src/fpu/fregfile.sv @@ -1,10 +1,9 @@ /////////////////////////////////////////// -// regfile.sv // // Written: David_Harris@hmc.edu 9 January 2021 -// Modified: +// Modified: James Stine // -// Purpose: 4-port register file +// Purpose: 3-port output register file // // A component of the Wally configurable RISC-V project. // @@ -26,22 +25,20 @@ `include "wally-config.vh" module fregfile ( - input logic clk, reset, - input logic we4, - input logic [ 4:0] a1, a2, a3, a4, - input logic [63:0] wd4, + input logic clk, reset, + input logic we4, + input logic [4:0] a1, a2, a3, a4, + input logic [63:0] wd4, output logic [63:0] rd1, rd2, rd3); - - logic [63:0] rf[31:0]; - integer i; - - // three ported register file - // read three ports combinationally (A1/RD1, A2/RD2, A3/RD3) - // write fourth port on rising edge of clock (A4/WD4/WE4) - // write occurs on falling edge of clock - - // reset is intended for simulation only, not synthesis - + + logic [63:0] rf[31:0]; + integer i; + + // three ported register file + // read three ports combinationally (A1/RD1, A2/RD2, A3/RD3) + // write fourth port on rising edge of clock (A4/WD4/WE4) + // write occurs on falling edge of clock + always_ff @(negedge clk or posedge reset) if (reset) for(i=0; i<32; i++) rf[i] <= 0; else if (we4) rf[a4] <= wd4; diff --git a/wally-pipelined/src/fpu/fsm.sv b/wally-pipelined/src/fpu/fsm.sv index 00f959930..a0e874bc7 100755 --- a/wally-pipelined/src/fpu/fsm.sv +++ b/wally-pipelined/src/fpu/fsm.sv @@ -1,49 +1,63 @@ -module fsm ( +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 9/28/2021 +// +// Purpose: FSM for floating point divider/square root unit (Goldschmidt) +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// - input logic clk, - input logic reset, - input logic start, - input logic op_type, - output logic done, // End of cycles - output logic load_rega, // enable for regA - output logic load_regb, // enable for regB - output logic load_regc, // enable for regC - output logic load_regd, // enable for regD - output logic load_regr, // enable for rem - output logic load_regs, // enable for q,qm,qp - output logic [2:0] sel_muxa, // Select muxA - output logic [2:0] sel_muxb, // Select muxB - output logic sel_muxr, // Select rem mux - output logic divBusy // calculation is happening +module fsm ( + input logic clk, + input logic reset, + input logic start, + input logic op_type, + output logic done, + output logic load_rega, + output logic load_regb, + output logic load_regc, + output logic load_regd, + output logic load_regr, + output logic load_regs, + output logic [2:0] sel_muxa, + output logic [2:0] sel_muxb, + output logic sel_muxr, + output logic divBusy ); - - reg [4:0] CURRENT_STATE; - reg [4:0] NEXT_STATE; - - parameter [4:0] - S0=5'd0, S1=5'd1, S2=5'd2, - S3=5'd3, S4=5'd4, S5=5'd5, - S6=5'd6, S7=5'd7, S8=5'd8, - S9=5'd9, S10=5'd10, - S13=5'd13, S14=5'd14, S15=5'd15, - S16=5'd16, S17=5'd17, S18=5'd18, - S19=5'd19, S20=5'd20, S21=5'd21, - S22=5'd22, S23=5'd23, S24=5'd24, - S25=5'd25, S26=5'd26, S27=5'd27, - S28=5'd28, S29=5'd29, S30=5'd30; + typedef enum logic [4:0] {S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, + S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, + S20, S21, S22, S23, S24, S25, S26, S27, S28, S29, + S30} statetype; + + statetype current_state, next_state; always @(negedge clk) begin - if(reset==1'b1) - CURRENT_STATE=S0; + if (reset == 1'b1) + current_state = S0; else - CURRENT_STATE=NEXT_STATE; + current_state = next_state; end always @(*) begin - case(CURRENT_STATE) + case(current_state) S0: // iteration 0 begin if (start==1'b0) @@ -59,7 +73,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S0; + next_state = S0; end else if (start==1'b1 && op_type==1'b0) begin @@ -74,7 +88,7 @@ module fsm ( sel_muxa = 3'b001; sel_muxb = 3'b001; sel_muxr = 1'b0; - NEXT_STATE = S1; + next_state = S1; end // if (start==1'b1 && op_type==1'b0) else if (start==1'b1 && op_type==1'b1) begin @@ -89,7 +103,7 @@ module fsm ( sel_muxa = 3'b010; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S13; + next_state = S13; end else begin @@ -104,7 +118,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S0; + next_state = S0; end end // case: S0 S1: @@ -120,7 +134,7 @@ module fsm ( sel_muxa = 3'b010; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S2; + next_state = S2; end S2: // iteration 1 begin @@ -135,7 +149,7 @@ module fsm ( sel_muxa = 3'b011; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S3; + next_state = S3; end S3: begin @@ -150,7 +164,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b010; sel_muxr = 1'b0; - NEXT_STATE = S4; + next_state = S4; end S4: // iteration 2 begin @@ -165,7 +179,7 @@ module fsm ( sel_muxa = 3'b011; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S5; + next_state = S5; end S5: begin @@ -180,7 +194,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b010; sel_muxr = 1'b0; // add - NEXT_STATE = S6; + next_state = S6; end S6: // iteration 3 begin @@ -195,7 +209,7 @@ module fsm ( sel_muxa = 3'b011; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S8; + next_state = S8; end S7: begin @@ -210,7 +224,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b010; sel_muxr = 1'b0; - NEXT_STATE = S8; + next_state = S8; end // case: S7 S8: // q,qm,qp begin @@ -225,7 +239,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S9; + next_state = S9; end S9: // rem begin @@ -240,7 +254,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b1; - NEXT_STATE = S10; + next_state = S10; end S10: // done begin @@ -255,7 +269,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S0; + next_state = S0; end S13: // start of sqrt path begin @@ -270,7 +284,7 @@ module fsm ( sel_muxa = 3'b010; sel_muxb = 3'b001; sel_muxr = 1'b0; - NEXT_STATE = S14; + next_state = S14; end S14: begin @@ -285,7 +299,7 @@ module fsm ( sel_muxa = 3'b001; sel_muxb = 3'b100; sel_muxr = 1'b0; - NEXT_STATE = S15; + next_state = S15; end S15: // iteration 1 begin @@ -300,7 +314,7 @@ module fsm ( sel_muxa = 3'b011; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S16; + next_state = S16; end S16: begin @@ -315,7 +329,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S17; + next_state = S17; end S17: begin @@ -330,7 +344,7 @@ module fsm ( sel_muxa = 3'b100; sel_muxb = 3'b010; sel_muxr = 1'b0; - NEXT_STATE = S18; + next_state = S18; end S18: // iteration 2 begin @@ -345,7 +359,7 @@ module fsm ( sel_muxa = 3'b011; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S19; + next_state = S19; end S19: begin @@ -360,7 +374,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S20; + next_state = S20; end S20: begin @@ -375,7 +389,7 @@ module fsm ( sel_muxa = 3'b100; sel_muxb = 3'b010; sel_muxr = 1'b0; - NEXT_STATE = S21; + next_state = S21; end S21: // iteration 3 begin @@ -390,7 +404,7 @@ module fsm ( sel_muxa = 3'b011; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S22; + next_state = S22; end S22: begin @@ -405,7 +419,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b011; sel_muxr = 1'b0; - NEXT_STATE = S23; + next_state = S23; end S23: begin @@ -420,7 +434,7 @@ module fsm ( sel_muxa = 3'b100; sel_muxb = 3'b010; sel_muxr = 1'b0; - NEXT_STATE = S24; + next_state = S24; end S24: // q,qm,qp begin @@ -435,7 +449,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S25; + next_state = S25; end S25: // rem begin @@ -450,7 +464,7 @@ module fsm ( sel_muxa = 3'b011; sel_muxb = 3'b110; sel_muxr = 1'b1; - NEXT_STATE = S26; + next_state = S26; end S26: // done begin @@ -465,7 +479,7 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S0; + next_state = S0; end default: begin @@ -480,9 +494,9 @@ module fsm ( sel_muxa = 3'b000; sel_muxb = 3'b000; sel_muxr = 1'b0; - NEXT_STATE = S0; + next_state = S0; end - endcase // case(CURRENT_STATE) - end // always @ (CURRENT_STATE or X) + endcase // case(current_state) + end // always @ (current_state or X) endmodule // fsm diff --git a/wally-pipelined/src/fpu/rounder_div.sv b/wally-pipelined/src/fpu/rounder_div.sv index ff7c4830f..1d2ff1cc3 100755 --- a/wally-pipelined/src/fpu/rounder_div.sv +++ b/wally-pipelined/src/fpu/rounder_div.sv @@ -1,37 +1,55 @@ +/////////////////////////////////////////// // -// The rounder takes as inputs a 64-bit value to be rounded, A, the -// exponent of the value to be rounded, the sign of the final result, Sign, -// the precision of the results, P, and the two-bit rounding mode, rm. -// It produces a rounded 52-bit result, Z, the exponent of the rounded -// result, Z_exp, and a flag that indicates if the result was rounded, -// Inexact. The rounding mode has the following values. -// rm Mode -// 00 round-to-nearest-even -// 01 round-toward-zero -// 10 round-toward-plus infinity -// 11 round-toward-minus infinity +// Written: James Stine +// Modified: 8/1/2018 // +// Purpose: Floating point divider/square root rounder unit (Goldschmidt) +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// module rounder_div ( - input logic [1:0] rm, - input logic P, - input logic OvEn, - input logic UnEn, - input logic [12:0] exp_diff, - input logic [2:0] sel_inv, - input logic Invalid, - input logic SignR, - - input logic [63:0] q1, - input logic [63:0] qm1, - input logic [63:0] qp1, - input logic [63:0] q0, - input logic [63:0] qm0, - input logic [63:0] qp0, + input logic [1:0] rm, + input logic P, + input logic OvEn, + input logic UnEn, + input logic [12:0] exp_diff, + input logic [2:0] sel_inv, + input logic Invalid, + input logic SignR, + input logic [63:0] Float1, + input logic [63:0] Float2, + input logic XNaNQ, + input logic YNaNQ, + input logic XZeroQ, + input logic YZeroQ, + input logic XInfQ, + input logic YInfQ, + input logic op_type, + input logic [63:0] q1, + input logic [63:0] qm1, + input logic [63:0] qp1, + input logic [63:0] q0, + input logic [63:0] qm0, + input logic [63:0] qp0, input logic [127:0] regr_out, output logic [63:0] Result, - output logic [4:0] Flags + output logic [4:0] Flags ); logic Rsign; @@ -56,11 +74,15 @@ module rounder_div ( logic Texp_l7z; logic Texp_l7o; logic OvCon; - logic zero_rem; - logic [1:0] mux_mant; + logic zero_rem; + logic [1:0] mux_mant; logic sign_rem; - logic [63:0] q, qm, qp; - logic exp_ovf; + logic [63:0] q, qm, qp; + logic exp_ovf; + + logic [50:0] NaN_out; + logic NaN_Sign_out; + logic Sign_out; // Remainder = 0? assign zero_rem = ~(|regr_out); @@ -117,12 +139,11 @@ module rounder_div ( // the input was infinite or NaN or the output of the adder is zero. // 00 = Valid // 10 = NaN - assign Valid = (~sel_inv[2]&~sel_inv[1]&~sel_inv[0]); - assign NaN = ~sel_inv[1]& sel_inv[0]; + assign Valid = ~sel_inv[2]&~sel_inv[1]&~sel_inv[0]; + assign NaN = sel_inv[2]&sel_inv[1]&sel_inv[0]; assign UnderFlow = (P & UnFlow_SP | UnFlow_DP) & Valid; assign OverFlow = (P & OvFlow_SP | OvFlow_DP) & Valid; - assign Div0 = sel_inv[2]&sel_inv[1]&~sel_inv[0]; - + assign Div0 = YZeroQ&~XZeroQ&~op_type&~NaN; // The final result is Inexact if any rounding occurred ((i.e., R or S // is one), or (if the result overflows ) or (if the result underflows and the @@ -161,18 +182,26 @@ module rounder_div ( // If the result is zero or infinity, the mantissa is all zeros. // If the result is NaN, the mantissa is 10...0 // If the result the largest floating point number, the mantissa - // is all ones. Otherwise, the mantissa is not changed. - assign Rmant[51] = Largest | NaN | (Smant[51]&~Infinite&~Rzero); - assign Rmant[50:0] = {51{Largest}} | (Smant[50:0]&{51{~Infinite&Valid&~Rzero}}); + // is all ones. Otherwise, the mantissa is not changed. + assign NaN_out = ~XNaNQ&YNaNQ ? Float2[50:0] : Float1[50:0]; + assign NaN_Sign_out = ~XNaNQ&YNaNQ ? Float2[63] : Float1[63]; + assign Sign_out = (XZeroQ&YZeroQ | XInfQ&YInfQ)&~op_type | Rsign&~XNaNQ&~YNaNQ | + NaN_Sign_out&(XNaNQ|YNaNQ); + // FIXME (jes) - Imperas gives sNaN a Sign=0 where x86 gives Sign=1 + // | Float1[63]&op_type; + assign Rmant[51] = Largest | NaN | (Smant[51]&~Infinite&~Rzero); + assign Rmant[50:0] = ({51{Largest}} | (Smant[50:0]&{51{~Infinite&Valid&~Rzero}}) | + (NaN_out&{51{NaN}}))&({51{~(op_type&Float1[63]&~XZeroQ)}}); + // For single precision, the 8 least significant bits of the exponent // and 23 most significant bits of the mantissa contain bits used // for the final result. A double precision result is returned if // overflow has occurred, the overflow trap is enabled, and a conversion // is being performed. assign OvCon = OverFlow & OvEn; - assign Result = (P&~OvCon) ? { {32{1'b1}}, Rsign, Rexp[7:0], Rmant[51:29]} - : {Rsign, Rexp, Rmant}; + assign Result = (P&~OvCon) ? { {32{1'b1}}, Sign_out, Rexp[7:0], Rmant[51:29]} + : {Sign_out, Rexp, Rmant}; endmodule // rounder diff --git a/wally-pipelined/src/fpu/sbtm_a0.sv b/wally-pipelined/src/fpu/sbtm_a0.sv index 83953787b..61dd183bb 100644 --- a/wally-pipelined/src/fpu/sbtm_a0.sv +++ b/wally-pipelined/src/fpu/sbtm_a0.sv @@ -1,5 +1,30 @@ +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 8/1/2018 +// +// Purpose: Bipartite Lookup +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// + module sbtm_a0 (input logic [6:0] a, - output logic [12:0] y); + output logic [12:0] y); + always_comb case(a) 7'b0000000: y = 13'b1111111100010; @@ -137,4 +162,4 @@ endmodule // sbtm_a0 - \ No newline at end of file + diff --git a/wally-pipelined/src/fpu/sbtm_a1.sv b/wally-pipelined/src/fpu/sbtm_a1.sv index 76e4bdec9..88845283c 100644 --- a/wally-pipelined/src/fpu/sbtm_a1.sv +++ b/wally-pipelined/src/fpu/sbtm_a1.sv @@ -1,5 +1,30 @@ +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 8/1/2018 +// +// Purpose: Bipartite Lookup +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// + module sbtm_a1 (input logic [6:0] a, - output logic [4:0] y); + output logic [4:0] y); + always_comb case(a) 7'b0000000: y = 5'b11100; @@ -137,4 +162,4 @@ endmodule // sbtm_a0 - \ No newline at end of file + diff --git a/wally-pipelined/src/fpu/sbtm_a2.sv b/wally-pipelined/src/fpu/sbtm_a2.sv index ae407ec81..8d32ad157 100755 --- a/wally-pipelined/src/fpu/sbtm_a2.sv +++ b/wally-pipelined/src/fpu/sbtm_a2.sv @@ -1,5 +1,30 @@ +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 8/1/2018 +// +// Purpose: Bipartite Lookup +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// + module sbtm_a2 (input logic [7:0] a, - output logic [13:0] y); + output logic [13:0] y); + always_comb case(a) 8'b01000000: y = 14'b10110100010111; @@ -201,4 +226,4 @@ endmodule // sbtm_a0 - \ No newline at end of file + diff --git a/wally-pipelined/src/fpu/sbtm_a3.sv b/wally-pipelined/src/fpu/sbtm_a3.sv index c6b367933..5958c3bf6 100755 --- a/wally-pipelined/src/fpu/sbtm_a3.sv +++ b/wally-pipelined/src/fpu/sbtm_a3.sv @@ -1,5 +1,30 @@ +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 8/1/2018 +// +// Purpose: Bipartite Lookup +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// + module sbtm_a3 (input logic [7:0] a, - output logic [5:0] y); + output logic [5:0] y); + always_comb case(a) 8'b01000000: y = 6'b100110; diff --git a/wally-pipelined/src/fpu/sbtm_div.sv b/wally-pipelined/src/fpu/sbtm_div.sv index 53b56dbd7..999106d86 100644 --- a/wally-pipelined/src/fpu/sbtm_div.sv +++ b/wally-pipelined/src/fpu/sbtm_div.sv @@ -1,3 +1,27 @@ +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 8/1/2018 +// +// Purpose: Bipartite Lookup for divide portion of fpdivsqrt +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// + module sbtm_div (input logic [11:0] a, output logic [10:0] ia_out); // bit partitions diff --git a/wally-pipelined/src/fpu/sbtm_sqrt.sv b/wally-pipelined/src/fpu/sbtm_sqrt.sv index 27ffbeccf..fdf0bb6df 100644 --- a/wally-pipelined/src/fpu/sbtm_sqrt.sv +++ b/wally-pipelined/src/fpu/sbtm_sqrt.sv @@ -1,3 +1,27 @@ +/////////////////////////////////////////// +// +// Written: James Stine +// Modified: 8/1/2018 +// +// Purpose: Bipartite Lookup for sqrt part of fpdivsqrt +// +// A component of the Wally configurable RISC-V project. +// +// Copyright (C) 2021 Harvey Mudd College & Oklahoma State University +// +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation +// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, +// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software +// is furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT +// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +/////////////////////////////////////////// + module sbtm_sqrt (input logic [11:0] a, output logic [10:0] y); // bit partitions From 2afa6e7a6e2930194b6af9ea43b9b020ca0cd8e3 Mon Sep 17 00:00:00 2001 From: "James E. Stine" Date: Wed, 6 Oct 2021 08:56:01 -0500 Subject: [PATCH 007/118] Add TV for testbenches (to be added shortly) however had to leave off fma due to size. The TV were slightly modified within TestFloat to add underscores for readability. The scripts I created to create these TV were also included --- .../testbench/fp/create_vectors32.csh | 30 +++++++++++++++++++ .../testbench/fp/create_vectors64.csh | 30 +++++++++++++++++++ 2 files changed, 60 insertions(+) create mode 100755 wally-pipelined/testbench/fp/create_vectors32.csh create mode 100755 wally-pipelined/testbench/fp/create_vectors64.csh diff --git a/wally-pipelined/testbench/fp/create_vectors32.csh b/wally-pipelined/testbench/fp/create_vectors32.csh new file mode 100755 index 000000000..1a43eb4c7 --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectors32.csh @@ -0,0 +1,30 @@ +#!/bin/sh +./testfloat_gen -rnear_even f32_add > f32_add_rne.tv +./testfloat_gen -rminMag f32_add > f32_add_rz.tv +./testfloat_gen -rmax f32_add > f32_add_ru.tv +./testfloat_gen -rmin f32_add > f32_add_rd.tv + +./testfloat_gen -rnear_even f32_sub > f32_sub_rne.tv +./testfloat_gen -rminMag f32_sub > f32_sub_rz.tv +./testfloat_gen -rmax f32_sub > f32_sub_ru.tv +./testfloat_gen -rmin f32_sub > f32_sub_rd.tv + +./testfloat_gen -rnear_even f32_mul > f32_mul_rne.tv +./testfloat_gen -rminMag f32_mul > f32_mul_rz.tv +./testfloat_gen -rmax f32_mul > f32_mul_ru.tv +./testfloat_gen -rmin f32_mul > f32_mul_rd.tv + +./testfloat_gen -rnear_even f32_mulAdd > f32_fma_rne.tv +./testfloat_gen -rminMag f32_mulAdd > f32_fma_rz.tv +./testfloat_gen -rmax f32_mulAdd > f32_fma_ru.tv +./testfloat_gen -rmin f32_mulAdd > f32_fma_rd.tv + +./testfloat_gen -rnear_even f32_div > f32_div_rne.tv +./testfloat_gen -rminMag f32_div > f32_div_rz.tv +./testfloat_gen -rmax f32_div > f32_div_ru.tv +./testfloat_gen -rmin f32_div > f32_div_rd.tv + +./testfloat_gen -rnear_even f32_sqrt > f32_sqrt_rne.tv +./testfloat_gen -rminMag f32_sqrt > f32_sqrt_rz.tv +./testfloat_gen -rmax f32_sqrt > f32_sqrt_ru.tv +./testfloat_gen -rmin f32_sqrt > f32_sqrt_rd.tv diff --git a/wally-pipelined/testbench/fp/create_vectors64.csh b/wally-pipelined/testbench/fp/create_vectors64.csh new file mode 100755 index 000000000..bb0c0fda6 --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectors64.csh @@ -0,0 +1,30 @@ +#!/bin/sh +./testfloat_gen -rnear_even f64_add > f64_add_rne.tv +./testfloat_gen -rminMag f64_add > f64_add_rz.tv +./testfloat_gen -rmax f64_add > f64_add_ru.tv +./testfloat_gen -rmin f64_add > f64_add_rd.tv + +./testfloat_gen -rnear_even f64_sub > f64_sub_rne.tv +./testfloat_gen -rminMag f64_sub > f64_sub_rz.tv +./testfloat_gen -rmax f64_sub > f64_sub_ru.tv +./testfloat_gen -rmin f64_sub > f64_sub_rd.tv + +./testfloat_gen -rnear_even f64_mul > f64_mul_rne.tv +./testfloat_gen -rminMag f64_mul > f64_mul_rz.tv +./testfloat_gen -rmax f64_mul > f64_mul_ru.tv +./testfloat_gen -rmin f64_mul > f64_mul_rd.tv + +./testfloat_gen -rnear_even f64_mulAdd > f64_fma_rne.tv +./testfloat_gen -rminMag f64_mulAdd > f64_fma_rz.tv +./testfloat_gen -rmax f64_mulAdd > f64_fma_ru.tv +./testfloat_gen -rmin f64_mulAdd > f64_fma_rd.tv + +./testfloat_gen -rnear_even f64_div > f64_div_rne.tv +./testfloat_gen -rminMag f64_div > f64_div_rz.tv +./testfloat_gen -rmax f64_div > f64_div_ru.tv +./testfloat_gen -rmin f64_div > f64_div_rd.tv + +./testfloat_gen -rnear_even f64_sqrt > f64_sqrt_rne.tv +./testfloat_gen -rminMag f64_sqrt > f64_sqrt_rz.tv +./testfloat_gen -rmax f64_sqrt > f64_sqrt_ru.tv +./testfloat_gen -rmin f64_sqrt > f64_sqrt_rd.tv From 93668b51851dcb715f08189868f25131a00aa8da Mon Sep 17 00:00:00 2001 From: "James E. Stine" Date: Wed, 6 Oct 2021 13:16:38 -0500 Subject: [PATCH 009/118] Update to testbench for FP stuff --- wally-pipelined/regression/sim-fp64 | 1 + wally-pipelined/regression/sim-fp64-batch | 3 + wally-pipelined/testbench/testbench-f64.sv | 129 +++++++++++++++++++++ 3 files changed, 133 insertions(+) create mode 100755 wally-pipelined/regression/sim-fp64 create mode 100755 wally-pipelined/regression/sim-fp64-batch create mode 100755 wally-pipelined/testbench/testbench-f64.sv diff --git a/wally-pipelined/regression/sim-fp64 b/wally-pipelined/regression/sim-fp64 new file mode 100755 index 000000000..b6b8ba5ca --- /dev/null +++ b/wally-pipelined/regression/sim-fp64 @@ -0,0 +1 @@ +vsim -do wally-fp64.do diff --git a/wally-pipelined/regression/sim-fp64-batch b/wally-pipelined/regression/sim-fp64-batch new file mode 100755 index 000000000..81ef807e2 --- /dev/null +++ b/wally-pipelined/regression/sim-fp64-batch @@ -0,0 +1,3 @@ +vsim -c < Date: Wed, 6 Oct 2021 13:17:49 -0500 Subject: [PATCH 010/118] Add generic wave command file --- .../regression/wave-dos/generic.do | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 wally-pipelined/regression/wave-dos/generic.do diff --git a/wally-pipelined/regression/wave-dos/generic.do b/wally-pipelined/regression/wave-dos/generic.do new file mode 100644 index 000000000..1d59f3fbe --- /dev/null +++ b/wally-pipelined/regression/wave-dos/generic.do @@ -0,0 +1,23 @@ +# default-waves.do +restart -f +delete wave /* +view wave + +# Diplays All Signals recursively +add wave /testbench/clk +add wave /testbench/reset +add wave -divider +add wave -hex -r /testbench/* + +# appearance +TreeUpdate [SetDefaultTree] +WaveRestoreZoom {0 ps} {300 ps} +configure wave -namecolwidth 350 +configure wave -valuecolwidth 150 +configure wave -justifyvalue left +configure wave -signalnamewidth 0 +configure wave -snapdistance 10 +configure wave -datasetprefix 0 +configure wave -rowmargin 4 +configure wave -childrowmargin 2 +set DefaultRadix hexadecimal From 8429078d4fa33d17bff0d18555b892d9db39960c Mon Sep 17 00:00:00 2001 From: "James E. Stine" Date: Wed, 6 Oct 2021 14:38:32 -0500 Subject: [PATCH 011/118] TV for conversion and compare --- .../testbench/fp/create_vectors16.csh | 22 + .../testbench/fp/create_vectors32.csh | 10 - .../testbench/fp/create_vectors32_64.csh | 5 + .../testbench/fp/create_vectors32cmp.csh | 9 + .../testbench/fp/create_vectors64.csh | 10 - .../testbench/fp/create_vectors64_32.csh | 5 + .../testbench/fp/create_vectors64cmp.csh | 9 + .../testbench/fp/create_vectorsi.csh | 23 + wally-pipelined/testbench/fp/i32_f32_rd.tv | 372 +++++++++ wally-pipelined/testbench/fp/i32_f32_rne.tv | 372 +++++++++ wally-pipelined/testbench/fp/i32_f32_ru.tv | 372 +++++++++ wally-pipelined/testbench/fp/i32_f32_rz.tv | 372 +++++++++ wally-pipelined/testbench/fp/i32_f64_rd.tv | 372 +++++++++ wally-pipelined/testbench/fp/i32_f64_rne.tv | 372 +++++++++ wally-pipelined/testbench/fp/i32_f64_ru.tv | 372 +++++++++ wally-pipelined/testbench/fp/i32_f64_rz.tv | 372 +++++++++ wally-pipelined/testbench/fp/i64_f32_rd.tv | 756 ++++++++++++++++++ wally-pipelined/testbench/fp/i64_f32_rne.tv | 756 ++++++++++++++++++ wally-pipelined/testbench/fp/i64_f32_ru.tv | 756 ++++++++++++++++++ wally-pipelined/testbench/fp/i64_f32_rz.tv | 756 ++++++++++++++++++ wally-pipelined/testbench/fp/i64_f64_rd.tv | 756 ++++++++++++++++++ wally-pipelined/testbench/fp/i64_f64_rne.tv | 756 ++++++++++++++++++ wally-pipelined/testbench/fp/i64_f64_ru.tv | 756 ++++++++++++++++++ wally-pipelined/testbench/fp/i64_f64_rz.tv | 756 ++++++++++++++++++ 24 files changed, 9097 insertions(+), 20 deletions(-) create mode 100755 wally-pipelined/testbench/fp/create_vectors16.csh create mode 100755 wally-pipelined/testbench/fp/create_vectors32_64.csh create mode 100755 wally-pipelined/testbench/fp/create_vectors32cmp.csh create mode 100755 wally-pipelined/testbench/fp/create_vectors64_32.csh create mode 100755 wally-pipelined/testbench/fp/create_vectors64cmp.csh create mode 100755 wally-pipelined/testbench/fp/create_vectorsi.csh create mode 100644 wally-pipelined/testbench/fp/i32_f32_rd.tv create mode 100644 wally-pipelined/testbench/fp/i32_f32_rne.tv create mode 100644 wally-pipelined/testbench/fp/i32_f32_ru.tv create mode 100644 wally-pipelined/testbench/fp/i32_f32_rz.tv create mode 100644 wally-pipelined/testbench/fp/i32_f64_rd.tv create mode 100644 wally-pipelined/testbench/fp/i32_f64_rne.tv create mode 100644 wally-pipelined/testbench/fp/i32_f64_ru.tv create mode 100644 wally-pipelined/testbench/fp/i32_f64_rz.tv create mode 100644 wally-pipelined/testbench/fp/i64_f32_rd.tv create mode 100644 wally-pipelined/testbench/fp/i64_f32_rne.tv create mode 100644 wally-pipelined/testbench/fp/i64_f32_ru.tv create mode 100644 wally-pipelined/testbench/fp/i64_f32_rz.tv create mode 100644 wally-pipelined/testbench/fp/i64_f64_rd.tv create mode 100644 wally-pipelined/testbench/fp/i64_f64_rne.tv create mode 100644 wally-pipelined/testbench/fp/i64_f64_ru.tv create mode 100644 wally-pipelined/testbench/fp/i64_f64_rz.tv diff --git a/wally-pipelined/testbench/fp/create_vectors16.csh b/wally-pipelined/testbench/fp/create_vectors16.csh new file mode 100755 index 000000000..9ce533218 --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectors16.csh @@ -0,0 +1,22 @@ +#!/bin/sh +./testfloat_gen -rnear_even f16_add > f16_add_rne.tv +./testfloat_gen -rminMag f16_add > f16_add_rz.tv +./testfloat_gen -rmin f16_add > f16_add_ru.tv +./testfloat_gen -rmax f16_add > f16_add_rd.tv + +./testfloat_gen -rnear_even f16_sub > f16_sub_rne.tv +./testfloat_gen -rminMag f16_sub > f16_sub_rz.tv +./testfloat_gen -rmin f16_sub > f16_sub_ru.tv +./testfloat_gen -rmax f16_sub > f16_sub_rd.tv + +./testfloat_gen -rnear_even f16_div > f16_div_rne.tv +./testfloat_gen -rminMag f16_div > f16_div_rz.tv +./testfloat_gen -rmin f16_div > f16_div_ru.tv +./testfloat_gen -rmax f16_div > f16_div_rd.tv + +./testfloat_gen -rnear_even f16_sqrt > f16_sqrt_rne.tv +./testfloat_gen -rminMag f16_sqrt > f16_sqrt_rz.tv +./testfloat_gen -rmin f16_sqrt > f16_sqrt_ru.tv +./testfloat_gen -rmax f16_sqrt > f16_sqrt_rd.tv + + diff --git a/wally-pipelined/testbench/fp/create_vectors32.csh b/wally-pipelined/testbench/fp/create_vectors32.csh index 1a43eb4c7..958c3fad3 100755 --- a/wally-pipelined/testbench/fp/create_vectors32.csh +++ b/wally-pipelined/testbench/fp/create_vectors32.csh @@ -9,16 +9,6 @@ ./testfloat_gen -rmax f32_sub > f32_sub_ru.tv ./testfloat_gen -rmin f32_sub > f32_sub_rd.tv -./testfloat_gen -rnear_even f32_mul > f32_mul_rne.tv -./testfloat_gen -rminMag f32_mul > f32_mul_rz.tv -./testfloat_gen -rmax f32_mul > f32_mul_ru.tv -./testfloat_gen -rmin f32_mul > f32_mul_rd.tv - -./testfloat_gen -rnear_even f32_mulAdd > f32_fma_rne.tv -./testfloat_gen -rminMag f32_mulAdd > f32_fma_rz.tv -./testfloat_gen -rmax f32_mulAdd > f32_fma_ru.tv -./testfloat_gen -rmin f32_mulAdd > f32_fma_rd.tv - ./testfloat_gen -rnear_even f32_div > f32_div_rne.tv ./testfloat_gen -rminMag f32_div > f32_div_rz.tv ./testfloat_gen -rmax f32_div > f32_div_ru.tv diff --git a/wally-pipelined/testbench/fp/create_vectors32_64.csh b/wally-pipelined/testbench/fp/create_vectors32_64.csh new file mode 100755 index 000000000..13f4c7bed --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectors32_64.csh @@ -0,0 +1,5 @@ +#!/bin/sh +./testfloat_gen -rnear_even f32_to_f64 > f32_f64_rne.tv +./testfloat_gen -rminMag f32_to_f64 > f32_f64_rz.tv +./testfloat_gen -rmax f32_to_f64 > f32_f64_ru.tv +./testfloat_gen -rmin f32_to_f64 > f32_f64_rd.tv diff --git a/wally-pipelined/testbench/fp/create_vectors32cmp.csh b/wally-pipelined/testbench/fp/create_vectors32cmp.csh new file mode 100755 index 000000000..d7356d3f7 --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectors32cmp.csh @@ -0,0 +1,9 @@ +#!/bin/sh +./testfloat_gen f32_eq > f32_cmp_eq.tv +./testfloat_gen f32_le > f32_cmp_le.tv +./testfloat_gen f32_lt > f32_cmp_lt.tv + +./testfloat_gen f32_eq_signaling > f32_cmp_eq_signaling.tv +./testfloat_gen f32_le_quiet > f32_cmp_le_quiet.tv +./testfloat_gen f32_lt_quiet > f32_cmp_lt_quiet.tv + diff --git a/wally-pipelined/testbench/fp/create_vectors64.csh b/wally-pipelined/testbench/fp/create_vectors64.csh index bb0c0fda6..fb4f3cef6 100755 --- a/wally-pipelined/testbench/fp/create_vectors64.csh +++ b/wally-pipelined/testbench/fp/create_vectors64.csh @@ -9,16 +9,6 @@ ./testfloat_gen -rmax f64_sub > f64_sub_ru.tv ./testfloat_gen -rmin f64_sub > f64_sub_rd.tv -./testfloat_gen -rnear_even f64_mul > f64_mul_rne.tv -./testfloat_gen -rminMag f64_mul > f64_mul_rz.tv -./testfloat_gen -rmax f64_mul > f64_mul_ru.tv -./testfloat_gen -rmin f64_mul > f64_mul_rd.tv - -./testfloat_gen -rnear_even f64_mulAdd > f64_fma_rne.tv -./testfloat_gen -rminMag f64_mulAdd > f64_fma_rz.tv -./testfloat_gen -rmax f64_mulAdd > f64_fma_ru.tv -./testfloat_gen -rmin f64_mulAdd > f64_fma_rd.tv - ./testfloat_gen -rnear_even f64_div > f64_div_rne.tv ./testfloat_gen -rminMag f64_div > f64_div_rz.tv ./testfloat_gen -rmax f64_div > f64_div_ru.tv diff --git a/wally-pipelined/testbench/fp/create_vectors64_32.csh b/wally-pipelined/testbench/fp/create_vectors64_32.csh new file mode 100755 index 000000000..3448d9c42 --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectors64_32.csh @@ -0,0 +1,5 @@ +#!/bin/sh +./testfloat_gen -rnear_even f64_to_f32 > f64_f32_rne.tv +./testfloat_gen -rminMag f64_to_f32 > f64_f32_rz.tv +./testfloat_gen -rmax f64_to_f32 > f64_f32_ru.tv +./testfloat_gen -rmin f64_to_f32 > f64_f32_rd.tv diff --git a/wally-pipelined/testbench/fp/create_vectors64cmp.csh b/wally-pipelined/testbench/fp/create_vectors64cmp.csh new file mode 100755 index 000000000..b2f5dd5b0 --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectors64cmp.csh @@ -0,0 +1,9 @@ +#!/bin/sh +./testfloat_gen f64_eq > f64_cmp_eq.tv +./testfloat_gen f64_le > f64_cmp_le.tv +./testfloat_gen f64_lt > f64_cmp_lt.tv + +./testfloat_gen f64_eq_signaling > f64_cmp_eq_signaling.tv +./testfloat_gen f64_le_quiet > f64_cmp_le_quiet.tv +./testfloat_gen f64_lt_quiet > f64_cmp_lt_quiet.tv + diff --git a/wally-pipelined/testbench/fp/create_vectorsi.csh b/wally-pipelined/testbench/fp/create_vectorsi.csh new file mode 100755 index 000000000..7a342e9fa --- /dev/null +++ b/wally-pipelined/testbench/fp/create_vectorsi.csh @@ -0,0 +1,23 @@ +#!/bin/sh +./testfloat_gen -rnear_even -i32_to_f64 > i32_f64_rne.tv +./testfloat_gen -rminMag -i32_to_f64 > i32_f64_rz.tv +./testfloat_gen -rmax -i32_to_f64 > i32_f64_ru.tv +./testfloat_gen -rmin -i32_to_f64 > i32_f64_rd.tv + +./testfloat_gen -rnear_even -i64_to_f64 > i64_f64_rne.tv +./testfloat_gen -rminMag -i64_to_f64 > i64_f64_rz.tv +./testfloat_gen -rmax -i64_to_f64 > i64_f64_ru.tv +./testfloat_gen -rmin -i64_to_f64 > i64_f64_rd.tv + +./testfloat_gen -rnear_even -i32_to_f32 > i32_f32_rne.tv +./testfloat_gen -rminMag -i32_to_f32 > i32_f32_rz.tv +./testfloat_gen -rmax -i32_to_f32 > i32_f32_ru.tv +./testfloat_gen -rmin -i32_to_f32 > i32_f32_rd.tv + +./testfloat_gen -rnear_even -i64_to_f32 > i64_f32_rne.tv +./testfloat_gen -rminMag -i64_to_f32 > i64_f32_rz.tv +./testfloat_gen -rmax -i64_to_f32 > i64_f32_ru.tv +./testfloat_gen -rmin -i64_to_f32 > i64_f32_rd.tv + + + diff --git a/wally-pipelined/testbench/fp/i32_f32_rd.tv b/wally-pipelined/testbench/fp/i32_f32_rd.tv new file mode 100644 index 000000000..e065d28ac --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f32_rd.tv @@ -0,0 +1,372 @@ +1FEFFFEF 4DFF7FFF_01 +FFFFC48E C66DC800_00 +00000000 00000000_00 +007FFFCD 4AFFFF9A_00 +00009E14 471E1400_00 +00000001 3F800000_00 +001FFFFB 49FFFFD8_00 +FFFFDE38 C6072000_00 +00000002 40000000_00 +FFDFFC02 CA000FF8_00 +FB794C79 CC90D671_01 +00000004 40800000_00 +F00FFFFE CD7F0001_01 +00000A95 45295000_00 +00000008 41000000_00 +FFFFF97F C4D02000_00 +FFAE458D CAA374E6_00 +00000010 41800000_00 +0101001E 4B80800F_00 +29EB4561 4E27AD15_01 +00000020 42000000_00 +8001FFEE CEFFFC01_01 +FFFBDD08 C8845F00_00 +00000040 42800000_00 +FFF03FF9 C97C0070_00 +FFCEDF36 CA448328_00 +00000080 43000000_00 +0000F01F 47701F00_00 +00000279 441E4000_00 +00000100 43800000_00 +BFFFFFEF CE800001_01 +00000007 40E00000_00 +00000200 44000000_00 +010BFFFD 4B85FFFE_01 +FFFFF590 C5270000_00 +00000400 44800000_00 +F7FFFEFB CD000011_01 +2FEA335F 4E3FA8CD_01 +00000800 45000000_00 +FFC07FFF CA7E0004_00 +177957FD 4DBBCABF_01 +00001000 45800000_00 +01FBFFEE 4BFDFFF7_00 +FFFFFAC9 C4A6E000_00 +00002000 46000000_00 +FFFF8004 C6FFF800_00 +FFFBE0DE C883E440_00 +00004000 46800000_00 +3F00001E 4E7C0000_01 +00000000 00000000_00 +00008000 47000000_00 +FF8201FF CAFBFC02_00 +FFFFD2F1 C6343C00_00 +00010000 47800000_00 +0000047E 448FC000_00 +0011B7E5 498DBF28_00 +00020000 48000000_00 +02200200 4C080080_00 +0013F7E6 499FBF30_00 +00040000 48800000_00 +FFFDC007 C80FFE40_00 +FD0ABD9A CC3D509A_01 +00080000 49000000_00 +0000607F 46C0FE00_00 +00003CEE 4673B800_00 +00100000 49800000_00 +DFDFE000 CE008080_00 +FFFB1642 C89D37C0_00 +00200000 4A000000_00 +FC000078 CC7FFFE2_00 +5F70EEC1 4EBEE1DD_01 +00400000 4A800000_00 +00100082 49800410_00 +FFFFFE21 C3EF8000_00 +00800000 4B000000_00 +FF7BFF7F CB040081_00 +FFFF6393 C71C6D00_00 +01000000 4B800000_00 +07EFFEFD 4CFDFFDF_01 +FFFFFDB4 C4130000_00 +02000000 4C000000_00 +8002FFFF CEFFFA01_01 +FFFFC8E2 C65C7800_00 +04000000 4C800000_00 +FFFC0DFE C87C8080_00 +FFFFFF1B C3650000_00 +08000000 4D000000_00 +03FFFDBF 4C7FFF6F_01 +0001092B 47849580_00 +10000000 4D800000_00 +007FBFFD 4AFF7FFA_00 +00B4F3D1 4B34F3D1_00 +20000000 4E000000_00 +FEF801FF CB83FF01_01 +00000005 40A00000_00 +40000000 4E800000_00 +BFF3FFFE CE801801_01 +0001806B 47C03580_00 +80000000 CF000000_00 +0000A07E 47207E00_00 +FFFFA59F C6B4C200_00 +C0000000 CE800000_00 +E0007FDE CDFFFC02_01 +FFF8343E C8F97840_00 +E0000000 CE000000_00 +0000FF7C 477F7C00_00 +FFFFFFF7 C1100000_00 +F0000000 CD800000_00 +BDFFFFFC CE840001_01 +FFFFE3C1 C5E1F800_00 +F8000000 CD000000_00 +28003FFE 4E2000FF_01 +00000000 00000000_00 +FC000000 CC800000_00 +00EEFFFF 4B6EFFFF_00 +00003EB0 467AC000_00 +FE000000 CC000000_00 +00000F7D 4577D000_00 +FFFFFF0F C3710000_00 +FF000000 CB800000_00 +0000406D 4680DA00_00 +0000001A 41D00000_00 +FF800000 CB000000_00 +203FFFFD 4E00FFFF_01 +0000000A 41200000_00 +FFC00000 CA800000_00 +FFFF007C C77F8400_00 +0000009B 431B0000_00 +FFE00000 CA000000_00 +00E00FFF 4B600FFF_00 +00000006 40C00000_00 +FFF00000 C9800000_00 +00200FFC 4A003FF0_00 +00000714 44E28000_00 +FFF80000 C9000000_00 +F800040E CCFFFF7F_01 +00000013 41980000_00 +FFFC0000 C8800000_00 +F83BFFFF CCF88001_01 +FFF3F584 C940A7C0_00 +FFFE0000 C8000000_00 +F6FFFBFF CD100041_01 +FFFFFFF0 C1800000_00 +FFFF0000 C7800000_00 +80003FFD CEFFFF81_01 +FFFFFFAD C2A60000_00 +FFFF8000 C7000000_00 +004001FD 4A8003FA_00 +000D734E 495734E0_00 +FFFFC000 C6800000_00 +006003FE 4AC007FC_00 +FF9DBAA8 CAC48AB0_00 +FFFFE000 C6000000_00 +000403EE 48807DC0_00 +00734668 4AE68CD0_00 +FFFFF000 C5800000_00 +01200002 4B900001_00 +FF8874A5 CAEF16B6_00 +FFFFF800 C5000000_00 +00060001 48C00020_00 +FFFFFFF8 C1000000_00 +FFFFFC00 C4800000_00 +001FFEDD 49FFF6E8_00 +FFFC56DF C86A4840_00 +FFFFFE00 C4000000_00 +EFFFEFFD CD800081_01 +FECF5EC6 CB98509D_00 +FFFFFF00 C3800000_00 +1FF00002 4DFF8000_01 +F6DB786B CD12487A_01 +FFFFFF80 C3000000_00 +F0000FBE CD7FFF05_01 +00000009 41100000_00 +FFFFFFC0 C2800000_00 +0010801F 498400F8_00 +0001F238 47F91C00_00 +FFFFFFE0 C2000000_00 +F8000047 CCFFFFF8_01 +0002133C 4804CF00_00 +FFFFFFF0 C1800000_00 +003C001F 4A70007C_00 +000001F1 43F88000_00 +FFFFFFF8 C1000000_00 +FFDFBFFF CA010004_00 +FF5E507F CB21AF81_00 +FFFFFFFC C0800000_00 +037FFFDE 4C5FFFF7_01 +FFFD7C6F C820E440_00 +FFFFFFFE C0000000_00 +000000FD 437D0000_00 +FFFFF42A C53D6000_00 +FFFFFFFF BF800000_00 +021FFF7D 4C07FFDF_01 +0000000A 41200000_00 +FFFFFFFD C0400000_00 +4010FFFF 4E8021FF_01 +FFFFFFD3 C2340000_00 +FFFFFFFB C0A00000_00 +FFFF800B C6FFEA00_00 +000000B8 43380000_00 +FFFFFFF7 C1100000_00 +FF800803 CAFFEFFA_00 +FFFFFFFE C0000000_00 +FFFFFFEF C1880000_00 +00803FFB 4B003FFB_00 +00000308 44420000_00 +FFFFFFDF C2040000_00 +2107FFFE 4E041FFF_01 +FFE15D4F C9F51588_00 +FFFFFFBF C2820000_00 +400087FD 4E80010F_01 +0000000F 41700000_00 +FFFFFF7F C3010000_00 +FDFC007E CC00FFE1_01 +00000006 40C00000_00 +FFFFFEFF C3808000_00 +FFF80100 C8FFE000_00 +FFFFFE99 C3B38000_00 +FFFFFDFF C4004000_00 +03000002 4C400000_01 +FFF716EA C90E9160_00 +FFFFFBFF C4802000_00 +C7FDFFFF CE600801_01 +FFFFE327 C5E6C800_00 +FFFFF7FF C5001000_00 +0103DFFE 4B81EFFF_00 +07661FD8 4CECC3FB_00 +FFFFEFFF C5800800_00 +83FFFFFE CEF80001_01 +FCD956DB CC49AA4A_01 +FFFFDFFF C6000400_00 +FF2001FD CB5FFE03_00 +E4D35BBF CDD96523_01 +FFFFBFFF C6800200_00 +DFEFEFFE CE004041_01 +05DA4300 4CBB4860_00 +FFFF7FFF C7000100_00 +40001040 4E800020_01 +812EDF40 CEFDA242_01 +FFFEFFFF C7800080_00 +FFFFC007 C67FE400_00 +00B6FCC9 4B36FCC9_00 +FFFDFFFF C8000040_00 +000007FE 44FFC000_00 +FC3DE950 CC7085AC_00 +FFFBFFFF C8800020_00 +7FFFFE03 4EFFFFFC_01 +FEB02B59 CBA7EA54_01 +FFF7FFFF C9000010_00 +10FF7FFF 4D87FBFF_01 +00008D5E 470D5E00_00 +FFEFFFFF C9800008_00 +FFFF007E C77F8200_00 +001C2108 49E10840_00 +FFDFFFFF CA000004_00 +00FFC001 4B7FC001_00 +F01C6B36 CD7E394D_01 +FFBFFFFF CA800002_00 +FFFF7FFF C7000100_00 +FFFFD055 C63EAC00_00 +FF7FFFFF CB000001_00 +027BFFFE 4C1EFFFF_01 +FF3090D0 CB4F6F30_00 +FEFFFFFF CB800001_01 +00082040 49020400_00 +0000006E 42DC0000_00 +FDFFFFFF CC000001_01 +FDFFFF87 CC00001F_01 +04C3764D 4C986EC9_01 +FBFFFFFF CC800001_01 +0006007E 48C00FC0_00 +000001EF 43F78000_00 +F7FFFFFF CD000001_01 +FFBF7FFE CA810004_00 +FF1C4E5A CB63B1A6_00 +EFFFFFFF CD800001_01 +FFF97FFD C8D00060_00 +000001D1 43E88000_00 +DFFFFFFF CE000001_01 +2FFFFFFE 4E3FFFFF_01 +00136721 499B3908_00 +BFFFFFFF CE800001_01 +00004BFF 4697FE00_00 +00000544 44A88000_00 +7FFFFFFF 4EFFFFFF_01 +007FDFFB 4AFFBFF6_00 +FFF8BD5E C8E85440_00 +3FFFFFFF 4E7FFFFF_01 +FFBF8003 CA80FFFA_00 +FFFE45D2 C7DD1700_00 +1FFFFFFF 4DFFFFFF_01 +FFFFFDBF C4104000_00 +FFFFF189 C5677000_00 +0FFFFFFF 4D7FFFFF_01 +FFFE6FFE C7C80100_00 +FC8672A0 CC5E6358_00 +07FFFFFF 4CFFFFFF_01 +00000107 43838000_00 +FFFCCA70 C84D6400_00 +03FFFFFF 4C7FFFFF_01 +002107FE 4A041FF8_00 +FFFF48E7 C7371900_00 +01FFFFFF 4BFFFFFF_01 +F7FDFFEE CD002002_01 +00000010 41800000_00 +00FFFFFF 4B7FFFFF_00 +FFFF01FD C77E0300_00 +0000FAEF 477AEF00_00 +007FFFFF 4AFFFFFE_00 +00FC0001 4B7C0001_00 +000000F5 43750000_00 +003FFFFF 4A7FFFFC_00 +FFE07FC0 C9FC0200_00 +001AFFFB 49D7FFD8_00 +001FFFFF 49FFFFF8_00 +00101FFD 4980FFE8_00 +FF4613B2 CB39EC4E_00 +000FFFFF 497FFFF0_00 +F00005FE CD7FFFA1_01 +00036402 48590080_00 +0007FFFF 48FFFFE0_00 +0404FFFF 4C809FFF_01 +021C2358 4C0708D6_00 +0003FFFF 487FFFC0_00 +FFFFFD02 C43F8000_00 +FFFF41C6 C73E3A00_00 +0001FFFF 47FFFF80_00 +00000007 40E00000_00 +27F174DE 4E1FC5D3_01 +0000FFFF 477FFF00_00 +000083F5 4703F500_00 +FFFFFFFB C0A00000_00 +00007FFF 46FFFE00_00 +FE7FDFFE CBC01001_00 +FFFFFFFD C0400000_00 +00003FFF 467FFC00_00 +DBBFFFFE CE110001_01 +00000404 44808000_00 +00001FFF 45FFF800_00 +FFFFC018 C67FA000_00 +00002853 46214C00_00 +00000FFF 457FF000_00 +03FE007F 4C7F801F_01 +FFFFF124 C56DC000_00 +000007FF 44FFE000_00 +FFFFEFBE C5821000_00 +FFFB9AD8 C88CA500_00 +000003FF 447FC000_00 +DFFFFDFE CE000009_01 +FFFFFD95 C41AC000_00 +000001FF 43FF8000_00 +FDFFFFFF CC000001_01 +FFFFFFD0 C2400000_00 +000000FF 437F0000_00 +0037FFE0 4A5FFF80_00 +010EC496 4B87624B_00 +0000007F 42FE0000_00 +B8007FFF CE8FFF01_01 +00000012 41900000_00 +0000003F 427C0000_00 +02003FFC 4C000FFF_00 +FFFFFFEF C1880000_00 +0000001F 41F80000_00 +FF7FFF02 CB0000FE_00 +FFFFE2CE C5E99000_00 +0000000F 41700000_00 +0000A00D 47200D00_00 +FFFFFE44 C3DE0000_00 +00000007 40E00000_00 +0003FFFA 487FFE80_00 +000038E7 46639C00_00 +00000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f32_rne.tv b/wally-pipelined/testbench/fp/i32_f32_rne.tv new file mode 100644 index 000000000..47d0f04bb --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f32_rne.tv @@ -0,0 +1,372 @@ +1FEFFFEF 4DFF7FFF_01 +FFFFC48E C66DC800_00 +00000000 00000000_00 +007FFFCD 4AFFFF9A_00 +00009E14 471E1400_00 +00000001 3F800000_00 +001FFFFB 49FFFFD8_00 +FFFFDE38 C6072000_00 +00000002 40000000_00 +FFDFFC02 CA000FF8_00 +FB794C79 CC90D671_01 +00000004 40800000_00 +F00FFFFE CD7F0000_01 +00000A95 45295000_00 +00000008 41000000_00 +FFFFF97F C4D02000_00 +FFAE458D CAA374E6_00 +00000010 41800000_00 +0101001E 4B80800F_00 +29EB4561 4E27AD16_01 +00000020 42000000_00 +8001FFEE CEFFFC00_01 +FFFBDD08 C8845F00_00 +00000040 42800000_00 +FFF03FF9 C97C0070_00 +FFCEDF36 CA448328_00 +00000080 43000000_00 +0000F01F 47701F00_00 +00000279 441E4000_00 +00000100 43800000_00 +BFFFFFEF CE800000_01 +00000007 40E00000_00 +00000200 44000000_00 +010BFFFD 4B85FFFE_01 +FFFFF590 C5270000_00 +00000400 44800000_00 +F7FFFEFB CD000010_01 +2FEA335F 4E3FA8CD_01 +00000800 45000000_00 +FFC07FFF CA7E0004_00 +177957FD 4DBBCAC0_01 +00001000 45800000_00 +01FBFFEE 4BFDFFF7_00 +FFFFFAC9 C4A6E000_00 +00002000 46000000_00 +FFFF8004 C6FFF800_00 +FFFBE0DE C883E440_00 +00004000 46800000_00 +3F00001E 4E7C0000_01 +00000000 00000000_00 +00008000 47000000_00 +FF8201FF CAFBFC02_00 +FFFFD2F1 C6343C00_00 +00010000 47800000_00 +0000047E 448FC000_00 +0011B7E5 498DBF28_00 +00020000 48000000_00 +02200200 4C080080_00 +0013F7E6 499FBF30_00 +00040000 48800000_00 +FFFDC007 C80FFE40_00 +FD0ABD9A CC3D509A_01 +00080000 49000000_00 +0000607F 46C0FE00_00 +00003CEE 4673B800_00 +00100000 49800000_00 +DFDFE000 CE008080_00 +FFFB1642 C89D37C0_00 +00200000 4A000000_00 +FC000078 CC7FFFE2_00 +5F70EEC1 4EBEE1DE_01 +00400000 4A800000_00 +00100082 49800410_00 +FFFFFE21 C3EF8000_00 +00800000 4B000000_00 +FF7BFF7F CB040081_00 +FFFF6393 C71C6D00_00 +01000000 4B800000_00 +07EFFEFD 4CFDFFE0_01 +FFFFFDB4 C4130000_00 +02000000 4C000000_00 +8002FFFF CEFFFA00_01 +FFFFC8E2 C65C7800_00 +04000000 4C800000_00 +FFFC0DFE C87C8080_00 +FFFFFF1B C3650000_00 +08000000 4D000000_00 +03FFFDBF 4C7FFF70_01 +0001092B 47849580_00 +10000000 4D800000_00 +007FBFFD 4AFF7FFA_00 +00B4F3D1 4B34F3D1_00 +20000000 4E000000_00 +FEF801FF CB83FF00_01 +00000005 40A00000_00 +40000000 4E800000_00 +BFF3FFFE CE801800_01 +0001806B 47C03580_00 +80000000 CF000000_00 +0000A07E 47207E00_00 +FFFFA59F C6B4C200_00 +C0000000 CE800000_00 +E0007FDE CDFFFC01_01 +FFF8343E C8F97840_00 +E0000000 CE000000_00 +0000FF7C 477F7C00_00 +FFFFFFF7 C1100000_00 +F0000000 CD800000_00 +BDFFFFFC CE840000_01 +FFFFE3C1 C5E1F800_00 +F8000000 CD000000_00 +28003FFE 4E200100_01 +00000000 00000000_00 +FC000000 CC800000_00 +00EEFFFF 4B6EFFFF_00 +00003EB0 467AC000_00 +FE000000 CC000000_00 +00000F7D 4577D000_00 +FFFFFF0F C3710000_00 +FF000000 CB800000_00 +0000406D 4680DA00_00 +0000001A 41D00000_00 +FF800000 CB000000_00 +203FFFFD 4E010000_01 +0000000A 41200000_00 +FFC00000 CA800000_00 +FFFF007C C77F8400_00 +0000009B 431B0000_00 +FFE00000 CA000000_00 +00E00FFF 4B600FFF_00 +00000006 40C00000_00 +FFF00000 C9800000_00 +00200FFC 4A003FF0_00 +00000714 44E28000_00 +FFF80000 C9000000_00 +F800040E CCFFFF7E_01 +00000013 41980000_00 +FFFC0000 C8800000_00 +F83BFFFF CCF88000_01 +FFF3F584 C940A7C0_00 +FFFE0000 C8000000_00 +F6FFFBFF CD100040_01 +FFFFFFF0 C1800000_00 +FFFF0000 C7800000_00 +80003FFD CEFFFF80_01 +FFFFFFAD C2A60000_00 +FFFF8000 C7000000_00 +004001FD 4A8003FA_00 +000D734E 495734E0_00 +FFFFC000 C6800000_00 +006003FE 4AC007FC_00 +FF9DBAA8 CAC48AB0_00 +FFFFE000 C6000000_00 +000403EE 48807DC0_00 +00734668 4AE68CD0_00 +FFFFF000 C5800000_00 +01200002 4B900001_00 +FF8874A5 CAEF16B6_00 +FFFFF800 C5000000_00 +00060001 48C00020_00 +FFFFFFF8 C1000000_00 +FFFFFC00 C4800000_00 +001FFEDD 49FFF6E8_00 +FFFC56DF C86A4840_00 +FFFFFE00 C4000000_00 +EFFFEFFD CD800080_01 +FECF5EC6 CB98509D_00 +FFFFFF00 C3800000_00 +1FF00002 4DFF8000_01 +F6DB786B CD124879_01 +FFFFFF80 C3000000_00 +F0000FBE CD7FFF04_01 +00000009 41100000_00 +FFFFFFC0 C2800000_00 +0010801F 498400F8_00 +0001F238 47F91C00_00 +FFFFFFE0 C2000000_00 +F8000047 CCFFFFF7_01 +0002133C 4804CF00_00 +FFFFFFF0 C1800000_00 +003C001F 4A70007C_00 +000001F1 43F88000_00 +FFFFFFF8 C1000000_00 +FFDFBFFF CA010004_00 +FF5E507F CB21AF81_00 +FFFFFFFC C0800000_00 +037FFFDE 4C5FFFF8_01 +FFFD7C6F C820E440_00 +FFFFFFFE C0000000_00 +000000FD 437D0000_00 +FFFFF42A C53D6000_00 +FFFFFFFF BF800000_00 +021FFF7D 4C07FFDF_01 +0000000A 41200000_00 +FFFFFFFD C0400000_00 +4010FFFF 4E802200_01 +FFFFFFD3 C2340000_00 +FFFFFFFB C0A00000_00 +FFFF800B C6FFEA00_00 +000000B8 43380000_00 +FFFFFFF7 C1100000_00 +FF800803 CAFFEFFA_00 +FFFFFFFE C0000000_00 +FFFFFFEF C1880000_00 +00803FFB 4B003FFB_00 +00000308 44420000_00 +FFFFFFDF C2040000_00 +2107FFFE 4E042000_01 +FFE15D4F C9F51588_00 +FFFFFFBF C2820000_00 +400087FD 4E800110_01 +0000000F 41700000_00 +FFFFFF7F C3010000_00 +FDFC007E CC00FFE0_01 +00000006 40C00000_00 +FFFFFEFF C3808000_00 +FFF80100 C8FFE000_00 +FFFFFE99 C3B38000_00 +FFFFFDFF C4004000_00 +03000002 4C400000_01 +FFF716EA C90E9160_00 +FFFFFBFF C4802000_00 +C7FDFFFF CE600800_01 +FFFFE327 C5E6C800_00 +FFFFF7FF C5001000_00 +0103DFFE 4B81EFFF_00 +07661FD8 4CECC3FB_00 +FFFFEFFF C5800800_00 +83FFFFFE CEF80000_01 +FCD956DB CC49AA49_01 +FFFFDFFF C6000400_00 +FF2001FD CB5FFE03_00 +E4D35BBF CDD96522_01 +FFFFBFFF C6800200_00 +DFEFEFFE CE004040_01 +05DA4300 4CBB4860_00 +FFFF7FFF C7000100_00 +40001040 4E800020_01 +812EDF40 CEFDA242_01 +FFFEFFFF C7800080_00 +FFFFC007 C67FE400_00 +00B6FCC9 4B36FCC9_00 +FFFDFFFF C8000040_00 +000007FE 44FFC000_00 +FC3DE950 CC7085AC_00 +FFFBFFFF C8800020_00 +7FFFFE03 4EFFFFFC_01 +FEB02B59 CBA7EA54_01 +FFF7FFFF C9000010_00 +10FF7FFF 4D87FC00_01 +00008D5E 470D5E00_00 +FFEFFFFF C9800008_00 +FFFF007E C77F8200_00 +001C2108 49E10840_00 +FFDFFFFF CA000004_00 +00FFC001 4B7FC001_00 +F01C6B36 CD7E394D_01 +FFBFFFFF CA800002_00 +FFFF7FFF C7000100_00 +FFFFD055 C63EAC00_00 +FF7FFFFF CB000001_00 +027BFFFE 4C1F0000_01 +FF3090D0 CB4F6F30_00 +FEFFFFFF CB800000_01 +00082040 49020400_00 +0000006E 42DC0000_00 +FDFFFFFF CC000000_01 +FDFFFF87 CC00001E_01 +04C3764D 4C986ECA_01 +FBFFFFFF CC800000_01 +0006007E 48C00FC0_00 +000001EF 43F78000_00 +F7FFFFFF CD000000_01 +FFBF7FFE CA810004_00 +FF1C4E5A CB63B1A6_00 +EFFFFFFF CD800000_01 +FFF97FFD C8D00060_00 +000001D1 43E88000_00 +DFFFFFFF CE000000_01 +2FFFFFFE 4E400000_01 +00136721 499B3908_00 +BFFFFFFF CE800000_01 +00004BFF 4697FE00_00 +00000544 44A88000_00 +7FFFFFFF 4F000000_01 +007FDFFB 4AFFBFF6_00 +FFF8BD5E C8E85440_00 +3FFFFFFF 4E800000_01 +FFBF8003 CA80FFFA_00 +FFFE45D2 C7DD1700_00 +1FFFFFFF 4E000000_01 +FFFFFDBF C4104000_00 +FFFFF189 C5677000_00 +0FFFFFFF 4D800000_01 +FFFE6FFE C7C80100_00 +FC8672A0 CC5E6358_00 +07FFFFFF 4D000000_01 +00000107 43838000_00 +FFFCCA70 C84D6400_00 +03FFFFFF 4C800000_01 +002107FE 4A041FF8_00 +FFFF48E7 C7371900_00 +01FFFFFF 4C000000_01 +F7FDFFEE CD002001_01 +00000010 41800000_00 +00FFFFFF 4B7FFFFF_00 +FFFF01FD C77E0300_00 +0000FAEF 477AEF00_00 +007FFFFF 4AFFFFFE_00 +00FC0001 4B7C0001_00 +000000F5 43750000_00 +003FFFFF 4A7FFFFC_00 +FFE07FC0 C9FC0200_00 +001AFFFB 49D7FFD8_00 +001FFFFF 49FFFFF8_00 +00101FFD 4980FFE8_00 +FF4613B2 CB39EC4E_00 +000FFFFF 497FFFF0_00 +F00005FE CD7FFFA0_01 +00036402 48590080_00 +0007FFFF 48FFFFE0_00 +0404FFFF 4C80A000_01 +021C2358 4C0708D6_00 +0003FFFF 487FFFC0_00 +FFFFFD02 C43F8000_00 +FFFF41C6 C73E3A00_00 +0001FFFF 47FFFF80_00 +00000007 40E00000_00 +27F174DE 4E1FC5D3_01 +0000FFFF 477FFF00_00 +000083F5 4703F500_00 +FFFFFFFB C0A00000_00 +00007FFF 46FFFE00_00 +FE7FDFFE CBC01001_00 +FFFFFFFD C0400000_00 +00003FFF 467FFC00_00 +DBBFFFFE CE110000_01 +00000404 44808000_00 +00001FFF 45FFF800_00 +FFFFC018 C67FA000_00 +00002853 46214C00_00 +00000FFF 457FF000_00 +03FE007F 4C7F8020_01 +FFFFF124 C56DC000_00 +000007FF 44FFE000_00 +FFFFEFBE C5821000_00 +FFFB9AD8 C88CA500_00 +000003FF 447FC000_00 +DFFFFDFE CE000008_01 +FFFFFD95 C41AC000_00 +000001FF 43FF8000_00 +FDFFFFFF CC000000_01 +FFFFFFD0 C2400000_00 +000000FF 437F0000_00 +0037FFE0 4A5FFF80_00 +010EC496 4B87624B_00 +0000007F 42FE0000_00 +B8007FFF CE8FFF00_01 +00000012 41900000_00 +0000003F 427C0000_00 +02003FFC 4C000FFF_00 +FFFFFFEF C1880000_00 +0000001F 41F80000_00 +FF7FFF02 CB0000FE_00 +FFFFE2CE C5E99000_00 +0000000F 41700000_00 +0000A00D 47200D00_00 +FFFFFE44 C3DE0000_00 +00000007 40E00000_00 +0003FFFA 487FFE80_00 +000038E7 46639C00_00 +00000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f32_ru.tv b/wally-pipelined/testbench/fp/i32_f32_ru.tv new file mode 100644 index 000000000..b13580f92 --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f32_ru.tv @@ -0,0 +1,372 @@ +1FEFFFEF 4DFF8000_01 +FFFFC48E C66DC800_00 +00000000 00000000_00 +007FFFCD 4AFFFF9A_00 +00009E14 471E1400_00 +00000001 3F800000_00 +001FFFFB 49FFFFD8_00 +FFFFDE38 C6072000_00 +00000002 40000000_00 +FFDFFC02 CA000FF8_00 +FB794C79 CC90D670_01 +00000004 40800000_00 +F00FFFFE CD7F0000_01 +00000A95 45295000_00 +00000008 41000000_00 +FFFFF97F C4D02000_00 +FFAE458D CAA374E6_00 +00000010 41800000_00 +0101001E 4B80800F_00 +29EB4561 4E27AD16_01 +00000020 42000000_00 +8001FFEE CEFFFC00_01 +FFFBDD08 C8845F00_00 +00000040 42800000_00 +FFF03FF9 C97C0070_00 +FFCEDF36 CA448328_00 +00000080 43000000_00 +0000F01F 47701F00_00 +00000279 441E4000_00 +00000100 43800000_00 +BFFFFFEF CE800000_01 +00000007 40E00000_00 +00000200 44000000_00 +010BFFFD 4B85FFFF_01 +FFFFF590 C5270000_00 +00000400 44800000_00 +F7FFFEFB CD000010_01 +2FEA335F 4E3FA8CE_01 +00000800 45000000_00 +FFC07FFF CA7E0004_00 +177957FD 4DBBCAC0_01 +00001000 45800000_00 +01FBFFEE 4BFDFFF7_00 +FFFFFAC9 C4A6E000_00 +00002000 46000000_00 +FFFF8004 C6FFF800_00 +FFFBE0DE C883E440_00 +00004000 46800000_00 +3F00001E 4E7C0001_01 +00000000 00000000_00 +00008000 47000000_00 +FF8201FF CAFBFC02_00 +FFFFD2F1 C6343C00_00 +00010000 47800000_00 +0000047E 448FC000_00 +0011B7E5 498DBF28_00 +00020000 48000000_00 +02200200 4C080080_00 +0013F7E6 499FBF30_00 +00040000 48800000_00 +FFFDC007 C80FFE40_00 +FD0ABD9A CC3D5099_01 +00080000 49000000_00 +0000607F 46C0FE00_00 +00003CEE 4673B800_00 +00100000 49800000_00 +DFDFE000 CE008080_00 +FFFB1642 C89D37C0_00 +00200000 4A000000_00 +FC000078 CC7FFFE2_00 +5F70EEC1 4EBEE1DE_01 +00400000 4A800000_00 +00100082 49800410_00 +FFFFFE21 C3EF8000_00 +00800000 4B000000_00 +FF7BFF7F CB040081_00 +FFFF6393 C71C6D00_00 +01000000 4B800000_00 +07EFFEFD 4CFDFFE0_01 +FFFFFDB4 C4130000_00 +02000000 4C000000_00 +8002FFFF CEFFFA00_01 +FFFFC8E2 C65C7800_00 +04000000 4C800000_00 +FFFC0DFE C87C8080_00 +FFFFFF1B C3650000_00 +08000000 4D000000_00 +03FFFDBF 4C7FFF70_01 +0001092B 47849580_00 +10000000 4D800000_00 +007FBFFD 4AFF7FFA_00 +00B4F3D1 4B34F3D1_00 +20000000 4E000000_00 +FEF801FF CB83FF00_01 +00000005 40A00000_00 +40000000 4E800000_00 +BFF3FFFE CE801800_01 +0001806B 47C03580_00 +80000000 CF000000_00 +0000A07E 47207E00_00 +FFFFA59F C6B4C200_00 +C0000000 CE800000_00 +E0007FDE CDFFFC01_01 +FFF8343E C8F97840_00 +E0000000 CE000000_00 +0000FF7C 477F7C00_00 +FFFFFFF7 C1100000_00 +F0000000 CD800000_00 +BDFFFFFC CE840000_01 +FFFFE3C1 C5E1F800_00 +F8000000 CD000000_00 +28003FFE 4E200100_01 +00000000 00000000_00 +FC000000 CC800000_00 +00EEFFFF 4B6EFFFF_00 +00003EB0 467AC000_00 +FE000000 CC000000_00 +00000F7D 4577D000_00 +FFFFFF0F C3710000_00 +FF000000 CB800000_00 +0000406D 4680DA00_00 +0000001A 41D00000_00 +FF800000 CB000000_00 +203FFFFD 4E010000_01 +0000000A 41200000_00 +FFC00000 CA800000_00 +FFFF007C C77F8400_00 +0000009B 431B0000_00 +FFE00000 CA000000_00 +00E00FFF 4B600FFF_00 +00000006 40C00000_00 +FFF00000 C9800000_00 +00200FFC 4A003FF0_00 +00000714 44E28000_00 +FFF80000 C9000000_00 +F800040E CCFFFF7E_01 +00000013 41980000_00 +FFFC0000 C8800000_00 +F83BFFFF CCF88000_01 +FFF3F584 C940A7C0_00 +FFFE0000 C8000000_00 +F6FFFBFF CD100040_01 +FFFFFFF0 C1800000_00 +FFFF0000 C7800000_00 +80003FFD CEFFFF80_01 +FFFFFFAD C2A60000_00 +FFFF8000 C7000000_00 +004001FD 4A8003FA_00 +000D734E 495734E0_00 +FFFFC000 C6800000_00 +006003FE 4AC007FC_00 +FF9DBAA8 CAC48AB0_00 +FFFFE000 C6000000_00 +000403EE 48807DC0_00 +00734668 4AE68CD0_00 +FFFFF000 C5800000_00 +01200002 4B900001_00 +FF8874A5 CAEF16B6_00 +FFFFF800 C5000000_00 +00060001 48C00020_00 +FFFFFFF8 C1000000_00 +FFFFFC00 C4800000_00 +001FFEDD 49FFF6E8_00 +FFFC56DF C86A4840_00 +FFFFFE00 C4000000_00 +EFFFEFFD CD800080_01 +FECF5EC6 CB98509D_00 +FFFFFF00 C3800000_00 +1FF00002 4DFF8001_01 +F6DB786B CD124879_01 +FFFFFF80 C3000000_00 +F0000FBE CD7FFF04_01 +00000009 41100000_00 +FFFFFFC0 C2800000_00 +0010801F 498400F8_00 +0001F238 47F91C00_00 +FFFFFFE0 C2000000_00 +F8000047 CCFFFFF7_01 +0002133C 4804CF00_00 +FFFFFFF0 C1800000_00 +003C001F 4A70007C_00 +000001F1 43F88000_00 +FFFFFFF8 C1000000_00 +FFDFBFFF CA010004_00 +FF5E507F CB21AF81_00 +FFFFFFFC C0800000_00 +037FFFDE 4C5FFFF8_01 +FFFD7C6F C820E440_00 +FFFFFFFE C0000000_00 +000000FD 437D0000_00 +FFFFF42A C53D6000_00 +FFFFFFFF BF800000_00 +021FFF7D 4C07FFE0_01 +0000000A 41200000_00 +FFFFFFFD C0400000_00 +4010FFFF 4E802200_01 +FFFFFFD3 C2340000_00 +FFFFFFFB C0A00000_00 +FFFF800B C6FFEA00_00 +000000B8 43380000_00 +FFFFFFF7 C1100000_00 +FF800803 CAFFEFFA_00 +FFFFFFFE C0000000_00 +FFFFFFEF C1880000_00 +00803FFB 4B003FFB_00 +00000308 44420000_00 +FFFFFFDF C2040000_00 +2107FFFE 4E042000_01 +FFE15D4F C9F51588_00 +FFFFFFBF C2820000_00 +400087FD 4E800110_01 +0000000F 41700000_00 +FFFFFF7F C3010000_00 +FDFC007E CC00FFE0_01 +00000006 40C00000_00 +FFFFFEFF C3808000_00 +FFF80100 C8FFE000_00 +FFFFFE99 C3B38000_00 +FFFFFDFF C4004000_00 +03000002 4C400001_01 +FFF716EA C90E9160_00 +FFFFFBFF C4802000_00 +C7FDFFFF CE600800_01 +FFFFE327 C5E6C800_00 +FFFFF7FF C5001000_00 +0103DFFE 4B81EFFF_00 +07661FD8 4CECC3FB_00 +FFFFEFFF C5800800_00 +83FFFFFE CEF80000_01 +FCD956DB CC49AA49_01 +FFFFDFFF C6000400_00 +FF2001FD CB5FFE03_00 +E4D35BBF CDD96522_01 +FFFFBFFF C6800200_00 +DFEFEFFE CE004040_01 +05DA4300 4CBB4860_00 +FFFF7FFF C7000100_00 +40001040 4E800021_01 +812EDF40 CEFDA241_01 +FFFEFFFF C7800080_00 +FFFFC007 C67FE400_00 +00B6FCC9 4B36FCC9_00 +FFFDFFFF C8000040_00 +000007FE 44FFC000_00 +FC3DE950 CC7085AC_00 +FFFBFFFF C8800020_00 +7FFFFE03 4EFFFFFD_01 +FEB02B59 CBA7EA53_01 +FFF7FFFF C9000010_00 +10FF7FFF 4D87FC00_01 +00008D5E 470D5E00_00 +FFEFFFFF C9800008_00 +FFFF007E C77F8200_00 +001C2108 49E10840_00 +FFDFFFFF CA000004_00 +00FFC001 4B7FC001_00 +F01C6B36 CD7E394C_01 +FFBFFFFF CA800002_00 +FFFF7FFF C7000100_00 +FFFFD055 C63EAC00_00 +FF7FFFFF CB000001_00 +027BFFFE 4C1F0000_01 +FF3090D0 CB4F6F30_00 +FEFFFFFF CB800000_01 +00082040 49020400_00 +0000006E 42DC0000_00 +FDFFFFFF CC000000_01 +FDFFFF87 CC00001E_01 +04C3764D 4C986ECA_01 +FBFFFFFF CC800000_01 +0006007E 48C00FC0_00 +000001EF 43F78000_00 +F7FFFFFF CD000000_01 +FFBF7FFE CA810004_00 +FF1C4E5A CB63B1A6_00 +EFFFFFFF CD800000_01 +FFF97FFD C8D00060_00 +000001D1 43E88000_00 +DFFFFFFF CE000000_01 +2FFFFFFE 4E400000_01 +00136721 499B3908_00 +BFFFFFFF CE800000_01 +00004BFF 4697FE00_00 +00000544 44A88000_00 +7FFFFFFF 4F000000_01 +007FDFFB 4AFFBFF6_00 +FFF8BD5E C8E85440_00 +3FFFFFFF 4E800000_01 +FFBF8003 CA80FFFA_00 +FFFE45D2 C7DD1700_00 +1FFFFFFF 4E000000_01 +FFFFFDBF C4104000_00 +FFFFF189 C5677000_00 +0FFFFFFF 4D800000_01 +FFFE6FFE C7C80100_00 +FC8672A0 CC5E6358_00 +07FFFFFF 4D000000_01 +00000107 43838000_00 +FFFCCA70 C84D6400_00 +03FFFFFF 4C800000_01 +002107FE 4A041FF8_00 +FFFF48E7 C7371900_00 +01FFFFFF 4C000000_01 +F7FDFFEE CD002001_01 +00000010 41800000_00 +00FFFFFF 4B7FFFFF_00 +FFFF01FD C77E0300_00 +0000FAEF 477AEF00_00 +007FFFFF 4AFFFFFE_00 +00FC0001 4B7C0001_00 +000000F5 43750000_00 +003FFFFF 4A7FFFFC_00 +FFE07FC0 C9FC0200_00 +001AFFFB 49D7FFD8_00 +001FFFFF 49FFFFF8_00 +00101FFD 4980FFE8_00 +FF4613B2 CB39EC4E_00 +000FFFFF 497FFFF0_00 +F00005FE CD7FFFA0_01 +00036402 48590080_00 +0007FFFF 48FFFFE0_00 +0404FFFF 4C80A000_01 +021C2358 4C0708D6_00 +0003FFFF 487FFFC0_00 +FFFFFD02 C43F8000_00 +FFFF41C6 C73E3A00_00 +0001FFFF 47FFFF80_00 +00000007 40E00000_00 +27F174DE 4E1FC5D4_01 +0000FFFF 477FFF00_00 +000083F5 4703F500_00 +FFFFFFFB C0A00000_00 +00007FFF 46FFFE00_00 +FE7FDFFE CBC01001_00 +FFFFFFFD C0400000_00 +00003FFF 467FFC00_00 +DBBFFFFE CE110000_01 +00000404 44808000_00 +00001FFF 45FFF800_00 +FFFFC018 C67FA000_00 +00002853 46214C00_00 +00000FFF 457FF000_00 +03FE007F 4C7F8020_01 +FFFFF124 C56DC000_00 +000007FF 44FFE000_00 +FFFFEFBE C5821000_00 +FFFB9AD8 C88CA500_00 +000003FF 447FC000_00 +DFFFFDFE CE000008_01 +FFFFFD95 C41AC000_00 +000001FF 43FF8000_00 +FDFFFFFF CC000000_01 +FFFFFFD0 C2400000_00 +000000FF 437F0000_00 +0037FFE0 4A5FFF80_00 +010EC496 4B87624B_00 +0000007F 42FE0000_00 +B8007FFF CE8FFF00_01 +00000012 41900000_00 +0000003F 427C0000_00 +02003FFC 4C000FFF_00 +FFFFFFEF C1880000_00 +0000001F 41F80000_00 +FF7FFF02 CB0000FE_00 +FFFFE2CE C5E99000_00 +0000000F 41700000_00 +0000A00D 47200D00_00 +FFFFFE44 C3DE0000_00 +00000007 40E00000_00 +0003FFFA 487FFE80_00 +000038E7 46639C00_00 +00000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f32_rz.tv b/wally-pipelined/testbench/fp/i32_f32_rz.tv new file mode 100644 index 000000000..7aa7eb823 --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f32_rz.tv @@ -0,0 +1,372 @@ +1FEFFFEF 4DFF7FFF_01 +FFFFC48E C66DC800_00 +00000000 00000000_00 +007FFFCD 4AFFFF9A_00 +00009E14 471E1400_00 +00000001 3F800000_00 +001FFFFB 49FFFFD8_00 +FFFFDE38 C6072000_00 +00000002 40000000_00 +FFDFFC02 CA000FF8_00 +FB794C79 CC90D670_01 +00000004 40800000_00 +F00FFFFE CD7F0000_01 +00000A95 45295000_00 +00000008 41000000_00 +FFFFF97F C4D02000_00 +FFAE458D CAA374E6_00 +00000010 41800000_00 +0101001E 4B80800F_00 +29EB4561 4E27AD15_01 +00000020 42000000_00 +8001FFEE CEFFFC00_01 +FFFBDD08 C8845F00_00 +00000040 42800000_00 +FFF03FF9 C97C0070_00 +FFCEDF36 CA448328_00 +00000080 43000000_00 +0000F01F 47701F00_00 +00000279 441E4000_00 +00000100 43800000_00 +BFFFFFEF CE800000_01 +00000007 40E00000_00 +00000200 44000000_00 +010BFFFD 4B85FFFE_01 +FFFFF590 C5270000_00 +00000400 44800000_00 +F7FFFEFB CD000010_01 +2FEA335F 4E3FA8CD_01 +00000800 45000000_00 +FFC07FFF CA7E0004_00 +177957FD 4DBBCABF_01 +00001000 45800000_00 +01FBFFEE 4BFDFFF7_00 +FFFFFAC9 C4A6E000_00 +00002000 46000000_00 +FFFF8004 C6FFF800_00 +FFFBE0DE C883E440_00 +00004000 46800000_00 +3F00001E 4E7C0000_01 +00000000 00000000_00 +00008000 47000000_00 +FF8201FF CAFBFC02_00 +FFFFD2F1 C6343C00_00 +00010000 47800000_00 +0000047E 448FC000_00 +0011B7E5 498DBF28_00 +00020000 48000000_00 +02200200 4C080080_00 +0013F7E6 499FBF30_00 +00040000 48800000_00 +FFFDC007 C80FFE40_00 +FD0ABD9A CC3D5099_01 +00080000 49000000_00 +0000607F 46C0FE00_00 +00003CEE 4673B800_00 +00100000 49800000_00 +DFDFE000 CE008080_00 +FFFB1642 C89D37C0_00 +00200000 4A000000_00 +FC000078 CC7FFFE2_00 +5F70EEC1 4EBEE1DD_01 +00400000 4A800000_00 +00100082 49800410_00 +FFFFFE21 C3EF8000_00 +00800000 4B000000_00 +FF7BFF7F CB040081_00 +FFFF6393 C71C6D00_00 +01000000 4B800000_00 +07EFFEFD 4CFDFFDF_01 +FFFFFDB4 C4130000_00 +02000000 4C000000_00 +8002FFFF CEFFFA00_01 +FFFFC8E2 C65C7800_00 +04000000 4C800000_00 +FFFC0DFE C87C8080_00 +FFFFFF1B C3650000_00 +08000000 4D000000_00 +03FFFDBF 4C7FFF6F_01 +0001092B 47849580_00 +10000000 4D800000_00 +007FBFFD 4AFF7FFA_00 +00B4F3D1 4B34F3D1_00 +20000000 4E000000_00 +FEF801FF CB83FF00_01 +00000005 40A00000_00 +40000000 4E800000_00 +BFF3FFFE CE801800_01 +0001806B 47C03580_00 +80000000 CF000000_00 +0000A07E 47207E00_00 +FFFFA59F C6B4C200_00 +C0000000 CE800000_00 +E0007FDE CDFFFC01_01 +FFF8343E C8F97840_00 +E0000000 CE000000_00 +0000FF7C 477F7C00_00 +FFFFFFF7 C1100000_00 +F0000000 CD800000_00 +BDFFFFFC CE840000_01 +FFFFE3C1 C5E1F800_00 +F8000000 CD000000_00 +28003FFE 4E2000FF_01 +00000000 00000000_00 +FC000000 CC800000_00 +00EEFFFF 4B6EFFFF_00 +00003EB0 467AC000_00 +FE000000 CC000000_00 +00000F7D 4577D000_00 +FFFFFF0F C3710000_00 +FF000000 CB800000_00 +0000406D 4680DA00_00 +0000001A 41D00000_00 +FF800000 CB000000_00 +203FFFFD 4E00FFFF_01 +0000000A 41200000_00 +FFC00000 CA800000_00 +FFFF007C C77F8400_00 +0000009B 431B0000_00 +FFE00000 CA000000_00 +00E00FFF 4B600FFF_00 +00000006 40C00000_00 +FFF00000 C9800000_00 +00200FFC 4A003FF0_00 +00000714 44E28000_00 +FFF80000 C9000000_00 +F800040E CCFFFF7E_01 +00000013 41980000_00 +FFFC0000 C8800000_00 +F83BFFFF CCF88000_01 +FFF3F584 C940A7C0_00 +FFFE0000 C8000000_00 +F6FFFBFF CD100040_01 +FFFFFFF0 C1800000_00 +FFFF0000 C7800000_00 +80003FFD CEFFFF80_01 +FFFFFFAD C2A60000_00 +FFFF8000 C7000000_00 +004001FD 4A8003FA_00 +000D734E 495734E0_00 +FFFFC000 C6800000_00 +006003FE 4AC007FC_00 +FF9DBAA8 CAC48AB0_00 +FFFFE000 C6000000_00 +000403EE 48807DC0_00 +00734668 4AE68CD0_00 +FFFFF000 C5800000_00 +01200002 4B900001_00 +FF8874A5 CAEF16B6_00 +FFFFF800 C5000000_00 +00060001 48C00020_00 +FFFFFFF8 C1000000_00 +FFFFFC00 C4800000_00 +001FFEDD 49FFF6E8_00 +FFFC56DF C86A4840_00 +FFFFFE00 C4000000_00 +EFFFEFFD CD800080_01 +FECF5EC6 CB98509D_00 +FFFFFF00 C3800000_00 +1FF00002 4DFF8000_01 +F6DB786B CD124879_01 +FFFFFF80 C3000000_00 +F0000FBE CD7FFF04_01 +00000009 41100000_00 +FFFFFFC0 C2800000_00 +0010801F 498400F8_00 +0001F238 47F91C00_00 +FFFFFFE0 C2000000_00 +F8000047 CCFFFFF7_01 +0002133C 4804CF00_00 +FFFFFFF0 C1800000_00 +003C001F 4A70007C_00 +000001F1 43F88000_00 +FFFFFFF8 C1000000_00 +FFDFBFFF CA010004_00 +FF5E507F CB21AF81_00 +FFFFFFFC C0800000_00 +037FFFDE 4C5FFFF7_01 +FFFD7C6F C820E440_00 +FFFFFFFE C0000000_00 +000000FD 437D0000_00 +FFFFF42A C53D6000_00 +FFFFFFFF BF800000_00 +021FFF7D 4C07FFDF_01 +0000000A 41200000_00 +FFFFFFFD C0400000_00 +4010FFFF 4E8021FF_01 +FFFFFFD3 C2340000_00 +FFFFFFFB C0A00000_00 +FFFF800B C6FFEA00_00 +000000B8 43380000_00 +FFFFFFF7 C1100000_00 +FF800803 CAFFEFFA_00 +FFFFFFFE C0000000_00 +FFFFFFEF C1880000_00 +00803FFB 4B003FFB_00 +00000308 44420000_00 +FFFFFFDF C2040000_00 +2107FFFE 4E041FFF_01 +FFE15D4F C9F51588_00 +FFFFFFBF C2820000_00 +400087FD 4E80010F_01 +0000000F 41700000_00 +FFFFFF7F C3010000_00 +FDFC007E CC00FFE0_01 +00000006 40C00000_00 +FFFFFEFF C3808000_00 +FFF80100 C8FFE000_00 +FFFFFE99 C3B38000_00 +FFFFFDFF C4004000_00 +03000002 4C400000_01 +FFF716EA C90E9160_00 +FFFFFBFF C4802000_00 +C7FDFFFF CE600800_01 +FFFFE327 C5E6C800_00 +FFFFF7FF C5001000_00 +0103DFFE 4B81EFFF_00 +07661FD8 4CECC3FB_00 +FFFFEFFF C5800800_00 +83FFFFFE CEF80000_01 +FCD956DB CC49AA49_01 +FFFFDFFF C6000400_00 +FF2001FD CB5FFE03_00 +E4D35BBF CDD96522_01 +FFFFBFFF C6800200_00 +DFEFEFFE CE004040_01 +05DA4300 4CBB4860_00 +FFFF7FFF C7000100_00 +40001040 4E800020_01 +812EDF40 CEFDA241_01 +FFFEFFFF C7800080_00 +FFFFC007 C67FE400_00 +00B6FCC9 4B36FCC9_00 +FFFDFFFF C8000040_00 +000007FE 44FFC000_00 +FC3DE950 CC7085AC_00 +FFFBFFFF C8800020_00 +7FFFFE03 4EFFFFFC_01 +FEB02B59 CBA7EA53_01 +FFF7FFFF C9000010_00 +10FF7FFF 4D87FBFF_01 +00008D5E 470D5E00_00 +FFEFFFFF C9800008_00 +FFFF007E C77F8200_00 +001C2108 49E10840_00 +FFDFFFFF CA000004_00 +00FFC001 4B7FC001_00 +F01C6B36 CD7E394C_01 +FFBFFFFF CA800002_00 +FFFF7FFF C7000100_00 +FFFFD055 C63EAC00_00 +FF7FFFFF CB000001_00 +027BFFFE 4C1EFFFF_01 +FF3090D0 CB4F6F30_00 +FEFFFFFF CB800000_01 +00082040 49020400_00 +0000006E 42DC0000_00 +FDFFFFFF CC000000_01 +FDFFFF87 CC00001E_01 +04C3764D 4C986EC9_01 +FBFFFFFF CC800000_01 +0006007E 48C00FC0_00 +000001EF 43F78000_00 +F7FFFFFF CD000000_01 +FFBF7FFE CA810004_00 +FF1C4E5A CB63B1A6_00 +EFFFFFFF CD800000_01 +FFF97FFD C8D00060_00 +000001D1 43E88000_00 +DFFFFFFF CE000000_01 +2FFFFFFE 4E3FFFFF_01 +00136721 499B3908_00 +BFFFFFFF CE800000_01 +00004BFF 4697FE00_00 +00000544 44A88000_00 +7FFFFFFF 4EFFFFFF_01 +007FDFFB 4AFFBFF6_00 +FFF8BD5E C8E85440_00 +3FFFFFFF 4E7FFFFF_01 +FFBF8003 CA80FFFA_00 +FFFE45D2 C7DD1700_00 +1FFFFFFF 4DFFFFFF_01 +FFFFFDBF C4104000_00 +FFFFF189 C5677000_00 +0FFFFFFF 4D7FFFFF_01 +FFFE6FFE C7C80100_00 +FC8672A0 CC5E6358_00 +07FFFFFF 4CFFFFFF_01 +00000107 43838000_00 +FFFCCA70 C84D6400_00 +03FFFFFF 4C7FFFFF_01 +002107FE 4A041FF8_00 +FFFF48E7 C7371900_00 +01FFFFFF 4BFFFFFF_01 +F7FDFFEE CD002001_01 +00000010 41800000_00 +00FFFFFF 4B7FFFFF_00 +FFFF01FD C77E0300_00 +0000FAEF 477AEF00_00 +007FFFFF 4AFFFFFE_00 +00FC0001 4B7C0001_00 +000000F5 43750000_00 +003FFFFF 4A7FFFFC_00 +FFE07FC0 C9FC0200_00 +001AFFFB 49D7FFD8_00 +001FFFFF 49FFFFF8_00 +00101FFD 4980FFE8_00 +FF4613B2 CB39EC4E_00 +000FFFFF 497FFFF0_00 +F00005FE CD7FFFA0_01 +00036402 48590080_00 +0007FFFF 48FFFFE0_00 +0404FFFF 4C809FFF_01 +021C2358 4C0708D6_00 +0003FFFF 487FFFC0_00 +FFFFFD02 C43F8000_00 +FFFF41C6 C73E3A00_00 +0001FFFF 47FFFF80_00 +00000007 40E00000_00 +27F174DE 4E1FC5D3_01 +0000FFFF 477FFF00_00 +000083F5 4703F500_00 +FFFFFFFB C0A00000_00 +00007FFF 46FFFE00_00 +FE7FDFFE CBC01001_00 +FFFFFFFD C0400000_00 +00003FFF 467FFC00_00 +DBBFFFFE CE110000_01 +00000404 44808000_00 +00001FFF 45FFF800_00 +FFFFC018 C67FA000_00 +00002853 46214C00_00 +00000FFF 457FF000_00 +03FE007F 4C7F801F_01 +FFFFF124 C56DC000_00 +000007FF 44FFE000_00 +FFFFEFBE C5821000_00 +FFFB9AD8 C88CA500_00 +000003FF 447FC000_00 +DFFFFDFE CE000008_01 +FFFFFD95 C41AC000_00 +000001FF 43FF8000_00 +FDFFFFFF CC000000_01 +FFFFFFD0 C2400000_00 +000000FF 437F0000_00 +0037FFE0 4A5FFF80_00 +010EC496 4B87624B_00 +0000007F 42FE0000_00 +B8007FFF CE8FFF00_01 +00000012 41900000_00 +0000003F 427C0000_00 +02003FFC 4C000FFF_00 +FFFFFFEF C1880000_00 +0000001F 41F80000_00 +FF7FFF02 CB0000FE_00 +FFFFE2CE C5E99000_00 +0000000F 41700000_00 +0000A00D 47200D00_00 +FFFFFE44 C3DE0000_00 +00000007 40E00000_00 +0003FFFA 487FFE80_00 +000038E7 46639C00_00 +00000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_rd.tv b/wally-pipelined/testbench/fp/i32_f64_rd.tv new file mode 100644 index 000000000..7f04b63fd --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f64_rd.tv @@ -0,0 +1,372 @@ +1FEFFFEF 41BFEFFFEF000000_00 +FFFFC48E C0CDB90000000000_00 +00000000 0000000000000000_00 +007FFFCD 415FFFF340000000_00 +00009E14 40E3C28000000000_00 +00000001 3FF0000000000000_00 +001FFFFB 413FFFFB00000000_00 +FFFFDE38 C0C0E40000000000_00 +00000002 4000000000000000_00 +FFDFFC02 C14001FF00000000_00 +FB794C79 C1921ACE1C000000_00 +00000004 4010000000000000_00 +F00FFFFE C1AFE00004000000_00 +00000A95 40A52A0000000000_00 +00000008 4020000000000000_00 +FFFFF97F C09A040000000000_00 +FFAE458D C1546E9CC0000000_00 +00000010 4030000000000000_00 +0101001E 41701001E0000000_00 +29EB4561 41C4F5A2B0800000_00 +00000020 4040000000000000_00 +8001FFEE C1DFFF8004800000_00 +FFFBDD08 C1108BE000000000_00 +00000040 4050000000000000_00 +FFF03FF9 C12F800E00000000_00 +FFCEDF36 C148906500000000_00 +00000080 4060000000000000_00 +0000F01F 40EE03E000000000_00 +00000279 4083C80000000000_00 +00000100 4070000000000000_00 +BFFFFFEF C1D0000004400000_00 +00000007 401C000000000000_00 +00000200 4080000000000000_00 +010BFFFD 4170BFFFD0000000_00 +FFFFF590 C0A4E00000000000_00 +00000400 4090000000000000_00 +F7FFFEFB C1A000020A000000_00 +2FEA335F 41C7F519AF800000_00 +00000800 40A0000000000000_00 +FFC07FFF C14FC00080000000_00 +177957FD 41B77957FD000000_00 +00001000 40B0000000000000_00 +01FBFFEE 417FBFFEE0000000_00 +FFFFFAC9 C094DC0000000000_00 +00002000 40C0000000000000_00 +FFFF8004 C0DFFF0000000000_00 +FFFBE0DE C1107C8800000000_00 +00004000 40D0000000000000_00 +3F00001E 41CF80000F000000_00 +00000000 0000000000000000_00 +00008000 40E0000000000000_00 +FF8201FF C15F7F8040000000_00 +FFFFD2F1 C0C6878000000000_00 +00010000 40F0000000000000_00 +0000047E 4091F80000000000_00 +0011B7E5 4131B7E500000000_00 +00020000 4100000000000000_00 +02200200 4181001000000000_00 +0013F7E6 4133F7E600000000_00 +00040000 4110000000000000_00 +FFFDC007 C101FFC800000000_00 +FD0ABD9A C187AA1330000000_00 +00080000 4120000000000000_00 +0000607F 40D81FC000000000_00 +00003CEE 40CE770000000000_00 +00100000 4130000000000000_00 +DFDFE000 C1C0101000000000_00 +FFFB1642 C113A6F800000000_00 +00200000 4140000000000000_00 +FC000078 C18FFFFC40000000_00 +5F70EEC1 41D7DC3BB0400000_00 +00400000 4150000000000000_00 +00100082 4130008200000000_00 +FFFFFE21 C07DF00000000000_00 +00800000 4160000000000000_00 +FF7BFF7F C160801020000000_00 +FFFF6393 C0E38DA000000000_00 +01000000 4170000000000000_00 +07EFFEFD 419FBFFBF4000000_00 +FFFFFDB4 C082600000000000_00 +02000000 4180000000000000_00 +8002FFFF C1DFFF4000400000_00 +FFFFC8E2 C0CB8F0000000000_00 +04000000 4190000000000000_00 +FFFC0DFE C10F901000000000_00 +FFFFFF1B C06CA00000000000_00 +08000000 41A0000000000000_00 +03FFFDBF 418FFFEDF8000000_00 +0001092B 40F092B000000000_00 +10000000 41B0000000000000_00 +007FBFFD 415FEFFF40000000_00 +00B4F3D1 41669E7A20000000_00 +20000000 41C0000000000000_00 +FEF801FF C1707FE010000000_00 +00000005 4014000000000000_00 +40000000 41D0000000000000_00 +BFF3FFFE C1D0030000800000_00 +0001806B 40F806B000000000_00 +80000000 C1E0000000000000_00 +0000A07E 40E40FC000000000_00 +FFFFA59F C0D6984000000000_00 +C0000000 C1D0000000000000_00 +E0007FDE C1BFFF8022000000_00 +FFF8343E C11F2F0800000000_00 +E0000000 C1C0000000000000_00 +0000FF7C 40EFEF8000000000_00 +FFFFFFF7 C022000000000000_00 +F0000000 C1B0000000000000_00 +BDFFFFFC C1D0800001000000_00 +FFFFE3C1 C0BC3F0000000000_00 +F8000000 C1A0000000000000_00 +28003FFE 41C4001FFF000000_00 +00000000 0000000000000000_00 +FC000000 C190000000000000_00 +00EEFFFF 416DDFFFE0000000_00 +00003EB0 40CF580000000000_00 +FE000000 C180000000000000_00 +00000F7D 40AEFA0000000000_00 +FFFFFF0F C06E200000000000_00 +FF000000 C170000000000000_00 +0000406D 40D01B4000000000_00 +0000001A 403A000000000000_00 +FF800000 C160000000000000_00 +203FFFFD 41C01FFFFE800000_00 +0000000A 4024000000000000_00 +FFC00000 C150000000000000_00 +FFFF007C C0EFF08000000000_00 +0000009B 4063600000000000_00 +FFE00000 C140000000000000_00 +00E00FFF 416C01FFE0000000_00 +00000006 4018000000000000_00 +FFF00000 C130000000000000_00 +00200FFC 414007FE00000000_00 +00000714 409C500000000000_00 +FFF80000 C120000000000000_00 +F800040E C19FFFEFC8000000_00 +00000013 4033000000000000_00 +FFFC0000 C110000000000000_00 +F83BFFFF C19F100004000000_00 +FFF3F584 C12814F800000000_00 +FFFE0000 C100000000000000_00 +F6FFFBFF C1A2000802000000_00 +FFFFFFF0 C030000000000000_00 +FFFF0000 C0F0000000000000_00 +80003FFD C1DFFFF000C00000_00 +FFFFFFAD C054C00000000000_00 +FFFF8000 C0E0000000000000_00 +004001FD 4150007F40000000_00 +000D734E 412AE69C00000000_00 +FFFFC000 C0D0000000000000_00 +006003FE 415800FF80000000_00 +FF9DBAA8 C158915600000000_00 +FFFFE000 C0C0000000000000_00 +000403EE 41100FB800000000_00 +00734668 415CD19A00000000_00 +FFFFF000 C0B0000000000000_00 +01200002 4172000020000000_00 +FF8874A5 C15DE2D6C0000000_00 +FFFFF800 C0A0000000000000_00 +00060001 4118000400000000_00 +FFFFFFF8 C020000000000000_00 +FFFFFC00 C090000000000000_00 +001FFEDD 413FFEDD00000000_00 +FFFC56DF C10D490800000000_00 +FFFFFE00 C080000000000000_00 +EFFFEFFD C1B0001003000000_00 +FECF5EC6 C1730A13A0000000_00 +FFFFFF00 C070000000000000_00 +1FF00002 41BFF00002000000_00 +F6DB786B C1A2490F2A000000_00 +FFFFFF80 C060000000000000_00 +F0000FBE C1AFFFE084000000_00 +00000009 4022000000000000_00 +FFFFFFC0 C050000000000000_00 +0010801F 4130801F00000000_00 +0001F238 40FF238000000000_00 +FFFFFFE0 C040000000000000_00 +F8000047 C19FFFFEE4000000_00 +0002133C 410099E000000000_00 +FFFFFFF0 C030000000000000_00 +003C001F 414E000F80000000_00 +000001F1 407F100000000000_00 +FFFFFFF8 C020000000000000_00 +FFDFBFFF C140200080000000_00 +FF5E507F C16435F020000000_00 +FFFFFFFC C010000000000000_00 +037FFFDE 418BFFFEF0000000_00 +FFFD7C6F C1041C8800000000_00 +FFFFFFFE C000000000000000_00 +000000FD 406FA00000000000_00 +FFFFF42A C0A7AC0000000000_00 +FFFFFFFF BFF0000000000000_00 +021FFF7D 4180FFFBE8000000_00 +0000000A 4024000000000000_00 +FFFFFFFD C008000000000000_00 +4010FFFF 41D0043FFFC00000_00 +FFFFFFD3 C046800000000000_00 +FFFFFFFB C014000000000000_00 +FFFF800B C0DFFD4000000000_00 +000000B8 4067000000000000_00 +FFFFFFF7 C022000000000000_00 +FF800803 C15FFDFF40000000_00 +FFFFFFFE C000000000000000_00 +FFFFFFEF C031000000000000_00 +00803FFB 416007FF60000000_00 +00000308 4088400000000000_00 +FFFFFFDF C040800000000000_00 +2107FFFE 41C083FFFF000000_00 +FFE15D4F C13EA2B100000000_00 +FFFFFFBF C050400000000000_00 +400087FD 41D00021FF400000_00 +0000000F 402E000000000000_00 +FFFFFF7F C060200000000000_00 +FDFC007E C1801FFC10000000_00 +00000006 4018000000000000_00 +FFFFFEFF C070100000000000_00 +FFF80100 C11FFC0000000000_00 +FFFFFE99 C076700000000000_00 +FFFFFDFF C080080000000000_00 +03000002 4188000010000000_00 +FFF716EA C121D22C00000000_00 +FFFFFBFF C090040000000000_00 +C7FDFFFF C1CC010000800000_00 +FFFFE327 C0BCD90000000000_00 +FFFFF7FF C0A0020000000000_00 +0103DFFE 41703DFFE0000000_00 +07661FD8 419D987F60000000_00 +FFFFEFFF C0B0010000000000_00 +83FFFFFE C1DF000000800000_00 +FCD956DB C189354928000000_00 +FFFFDFFF C0C0008000000000_00 +FF2001FD C16BFFC060000000_00 +E4D35BBF C1BB2CA441000000_00 +FFFFBFFF C0D0004000000000_00 +DFEFEFFE C1C0080801000000_00 +05DA4300 4197690C00000000_00 +FFFF7FFF C0E0002000000000_00 +40001040 41D0000410000000_00 +812EDF40 C1DFB44830000000_00 +FFFEFFFF C0F0001000000000_00 +FFFFC007 C0CFFC8000000000_00 +00B6FCC9 4166DF9920000000_00 +FFFDFFFF C100000800000000_00 +000007FE 409FF80000000000_00 +FC3DE950 C18E10B580000000_00 +FFFBFFFF C110000400000000_00 +7FFFFE03 41DFFFFF80C00000_00 +FEB02B59 C174FD4A70000000_00 +FFF7FFFF C120000200000000_00 +10FF7FFF 41B0FF7FFF000000_00 +00008D5E 40E1ABC000000000_00 +FFEFFFFF C130000100000000_00 +FFFF007E C0EFF04000000000_00 +001C2108 413C210800000000_00 +FFDFFFFF C140000080000000_00 +00FFC001 416FF80020000000_00 +F01C6B36 C1AFC72994000000_00 +FFBFFFFF C150000040000000_00 +FFFF7FFF C0E0002000000000_00 +FFFFD055 C0C7D58000000000_00 +FF7FFFFF C160000020000000_00 +027BFFFE 4183DFFFF0000000_00 +FF3090D0 C169EDE600000000_00 +FEFFFFFF C170000010000000_00 +00082040 4120408000000000_00 +0000006E 405B800000000000_00 +FDFFFFFF C180000008000000_00 +FDFFFF87 C1800003C8000000_00 +04C3764D 41930DD934000000_00 +FBFFFFFF C190000004000000_00 +0006007E 411801F800000000_00 +000001EF 407EF00000000000_00 +F7FFFFFF C1A0000002000000_00 +FFBF7FFE C150200080000000_00 +FF1C4E5A C16C7634C0000000_00 +EFFFFFFF C1B0000001000000_00 +FFF97FFD C11A000C00000000_00 +000001D1 407D100000000000_00 +DFFFFFFF C1C0000000800000_00 +2FFFFFFE 41C7FFFFFF000000_00 +00136721 4133672100000000_00 +BFFFFFFF C1D0000000400000_00 +00004BFF 40D2FFC000000000_00 +00000544 4095100000000000_00 +7FFFFFFF 41DFFFFFFFC00000_00 +007FDFFB 415FF7FEC0000000_00 +FFF8BD5E C11D0A8800000000_00 +3FFFFFFF 41CFFFFFFF800000_00 +FFBF8003 C1501FFF40000000_00 +FFFE45D2 C0FBA2E000000000_00 +1FFFFFFF 41BFFFFFFF000000_00 +FFFFFDBF C082080000000000_00 +FFFFF189 C0ACEE0000000000_00 +0FFFFFFF 41AFFFFFFE000000_00 +FFFE6FFE C0F9002000000000_00 +FC8672A0 C18BCC6B00000000_00 +07FFFFFF 419FFFFFFC000000_00 +00000107 4070700000000000_00 +FFFCCA70 C109AC8000000000_00 +03FFFFFF 418FFFFFF8000000_00 +002107FE 414083FF00000000_00 +FFFF48E7 C0E6E32000000000_00 +01FFFFFF 417FFFFFF0000000_00 +F7FDFFEE C1A0040024000000_00 +00000010 4030000000000000_00 +00FFFFFF 416FFFFFE0000000_00 +FFFF01FD C0EFC06000000000_00 +0000FAEF 40EF5DE000000000_00 +007FFFFF 415FFFFFC0000000_00 +00FC0001 416F800020000000_00 +000000F5 406EA00000000000_00 +003FFFFF 414FFFFF80000000_00 +FFE07FC0 C13F804000000000_00 +001AFFFB 413AFFFB00000000_00 +001FFFFF 413FFFFF00000000_00 +00101FFD 41301FFD00000000_00 +FF4613B2 C1673D89C0000000_00 +000FFFFF 412FFFFE00000000_00 +F00005FE C1AFFFF404000000_00 +00036402 410B201000000000_00 +0007FFFF 411FFFFC00000000_00 +0404FFFF 419013FFFC000000_00 +021C2358 4180E11AC0000000_00 +0003FFFF 410FFFF800000000_00 +FFFFFD02 C087F00000000000_00 +FFFF41C6 C0E7C74000000000_00 +0001FFFF 40FFFFF000000000_00 +00000007 401C000000000000_00 +27F174DE 41C3F8BA6F000000_00 +0000FFFF 40EFFFE000000000_00 +000083F5 40E07EA000000000_00 +FFFFFFFB C014000000000000_00 +00007FFF 40DFFFC000000000_00 +FE7FDFFE C178020020000000_00 +FFFFFFFD C008000000000000_00 +00003FFF 40CFFF8000000000_00 +DBBFFFFE C1C2200001000000_00 +00000404 4090100000000000_00 +00001FFF 40BFFF0000000000_00 +FFFFC018 C0CFF40000000000_00 +00002853 40C4298000000000_00 +00000FFF 40AFFE0000000000_00 +03FE007F 418FF003F8000000_00 +FFFFF124 C0ADB80000000000_00 +000007FF 409FFC0000000000_00 +FFFFEFBE C0B0420000000000_00 +FFFB9AD8 C11194A000000000_00 +000003FF 408FF80000000000_00 +DFFFFDFE C1C0000101000000_00 +FFFFFD95 C083580000000000_00 +000001FF 407FF00000000000_00 +FDFFFFFF C180000008000000_00 +FFFFFFD0 C048000000000000_00 +000000FF 406FE00000000000_00 +0037FFE0 414BFFF000000000_00 +010EC496 4170EC4960000000_00 +0000007F 405FC00000000000_00 +B8007FFF C1D1FFE000400000_00 +00000012 4032000000000000_00 +0000003F 404F800000000000_00 +02003FFC 418001FFE0000000_00 +FFFFFFEF C031000000000000_00 +0000001F 403F000000000000_00 +FF7FFF02 C160001FC0000000_00 +FFFFE2CE C0BD320000000000_00 +0000000F 402E000000000000_00 +0000A00D 40E401A000000000_00 +FFFFFE44 C07BC00000000000_00 +00000007 401C000000000000_00 +0003FFFA 410FFFD000000000_00 +000038E7 40CC738000000000_00 +00000003 4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_rne.tv b/wally-pipelined/testbench/fp/i32_f64_rne.tv new file mode 100644 index 000000000..7f04b63fd --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f64_rne.tv @@ -0,0 +1,372 @@ +1FEFFFEF 41BFEFFFEF000000_00 +FFFFC48E C0CDB90000000000_00 +00000000 0000000000000000_00 +007FFFCD 415FFFF340000000_00 +00009E14 40E3C28000000000_00 +00000001 3FF0000000000000_00 +001FFFFB 413FFFFB00000000_00 +FFFFDE38 C0C0E40000000000_00 +00000002 4000000000000000_00 +FFDFFC02 C14001FF00000000_00 +FB794C79 C1921ACE1C000000_00 +00000004 4010000000000000_00 +F00FFFFE C1AFE00004000000_00 +00000A95 40A52A0000000000_00 +00000008 4020000000000000_00 +FFFFF97F C09A040000000000_00 +FFAE458D C1546E9CC0000000_00 +00000010 4030000000000000_00 +0101001E 41701001E0000000_00 +29EB4561 41C4F5A2B0800000_00 +00000020 4040000000000000_00 +8001FFEE C1DFFF8004800000_00 +FFFBDD08 C1108BE000000000_00 +00000040 4050000000000000_00 +FFF03FF9 C12F800E00000000_00 +FFCEDF36 C148906500000000_00 +00000080 4060000000000000_00 +0000F01F 40EE03E000000000_00 +00000279 4083C80000000000_00 +00000100 4070000000000000_00 +BFFFFFEF C1D0000004400000_00 +00000007 401C000000000000_00 +00000200 4080000000000000_00 +010BFFFD 4170BFFFD0000000_00 +FFFFF590 C0A4E00000000000_00 +00000400 4090000000000000_00 +F7FFFEFB C1A000020A000000_00 +2FEA335F 41C7F519AF800000_00 +00000800 40A0000000000000_00 +FFC07FFF C14FC00080000000_00 +177957FD 41B77957FD000000_00 +00001000 40B0000000000000_00 +01FBFFEE 417FBFFEE0000000_00 +FFFFFAC9 C094DC0000000000_00 +00002000 40C0000000000000_00 +FFFF8004 C0DFFF0000000000_00 +FFFBE0DE C1107C8800000000_00 +00004000 40D0000000000000_00 +3F00001E 41CF80000F000000_00 +00000000 0000000000000000_00 +00008000 40E0000000000000_00 +FF8201FF C15F7F8040000000_00 +FFFFD2F1 C0C6878000000000_00 +00010000 40F0000000000000_00 +0000047E 4091F80000000000_00 +0011B7E5 4131B7E500000000_00 +00020000 4100000000000000_00 +02200200 4181001000000000_00 +0013F7E6 4133F7E600000000_00 +00040000 4110000000000000_00 +FFFDC007 C101FFC800000000_00 +FD0ABD9A C187AA1330000000_00 +00080000 4120000000000000_00 +0000607F 40D81FC000000000_00 +00003CEE 40CE770000000000_00 +00100000 4130000000000000_00 +DFDFE000 C1C0101000000000_00 +FFFB1642 C113A6F800000000_00 +00200000 4140000000000000_00 +FC000078 C18FFFFC40000000_00 +5F70EEC1 41D7DC3BB0400000_00 +00400000 4150000000000000_00 +00100082 4130008200000000_00 +FFFFFE21 C07DF00000000000_00 +00800000 4160000000000000_00 +FF7BFF7F C160801020000000_00 +FFFF6393 C0E38DA000000000_00 +01000000 4170000000000000_00 +07EFFEFD 419FBFFBF4000000_00 +FFFFFDB4 C082600000000000_00 +02000000 4180000000000000_00 +8002FFFF C1DFFF4000400000_00 +FFFFC8E2 C0CB8F0000000000_00 +04000000 4190000000000000_00 +FFFC0DFE C10F901000000000_00 +FFFFFF1B C06CA00000000000_00 +08000000 41A0000000000000_00 +03FFFDBF 418FFFEDF8000000_00 +0001092B 40F092B000000000_00 +10000000 41B0000000000000_00 +007FBFFD 415FEFFF40000000_00 +00B4F3D1 41669E7A20000000_00 +20000000 41C0000000000000_00 +FEF801FF C1707FE010000000_00 +00000005 4014000000000000_00 +40000000 41D0000000000000_00 +BFF3FFFE C1D0030000800000_00 +0001806B 40F806B000000000_00 +80000000 C1E0000000000000_00 +0000A07E 40E40FC000000000_00 +FFFFA59F C0D6984000000000_00 +C0000000 C1D0000000000000_00 +E0007FDE C1BFFF8022000000_00 +FFF8343E C11F2F0800000000_00 +E0000000 C1C0000000000000_00 +0000FF7C 40EFEF8000000000_00 +FFFFFFF7 C022000000000000_00 +F0000000 C1B0000000000000_00 +BDFFFFFC C1D0800001000000_00 +FFFFE3C1 C0BC3F0000000000_00 +F8000000 C1A0000000000000_00 +28003FFE 41C4001FFF000000_00 +00000000 0000000000000000_00 +FC000000 C190000000000000_00 +00EEFFFF 416DDFFFE0000000_00 +00003EB0 40CF580000000000_00 +FE000000 C180000000000000_00 +00000F7D 40AEFA0000000000_00 +FFFFFF0F C06E200000000000_00 +FF000000 C170000000000000_00 +0000406D 40D01B4000000000_00 +0000001A 403A000000000000_00 +FF800000 C160000000000000_00 +203FFFFD 41C01FFFFE800000_00 +0000000A 4024000000000000_00 +FFC00000 C150000000000000_00 +FFFF007C C0EFF08000000000_00 +0000009B 4063600000000000_00 +FFE00000 C140000000000000_00 +00E00FFF 416C01FFE0000000_00 +00000006 4018000000000000_00 +FFF00000 C130000000000000_00 +00200FFC 414007FE00000000_00 +00000714 409C500000000000_00 +FFF80000 C120000000000000_00 +F800040E C19FFFEFC8000000_00 +00000013 4033000000000000_00 +FFFC0000 C110000000000000_00 +F83BFFFF C19F100004000000_00 +FFF3F584 C12814F800000000_00 +FFFE0000 C100000000000000_00 +F6FFFBFF C1A2000802000000_00 +FFFFFFF0 C030000000000000_00 +FFFF0000 C0F0000000000000_00 +80003FFD C1DFFFF000C00000_00 +FFFFFFAD C054C00000000000_00 +FFFF8000 C0E0000000000000_00 +004001FD 4150007F40000000_00 +000D734E 412AE69C00000000_00 +FFFFC000 C0D0000000000000_00 +006003FE 415800FF80000000_00 +FF9DBAA8 C158915600000000_00 +FFFFE000 C0C0000000000000_00 +000403EE 41100FB800000000_00 +00734668 415CD19A00000000_00 +FFFFF000 C0B0000000000000_00 +01200002 4172000020000000_00 +FF8874A5 C15DE2D6C0000000_00 +FFFFF800 C0A0000000000000_00 +00060001 4118000400000000_00 +FFFFFFF8 C020000000000000_00 +FFFFFC00 C090000000000000_00 +001FFEDD 413FFEDD00000000_00 +FFFC56DF C10D490800000000_00 +FFFFFE00 C080000000000000_00 +EFFFEFFD C1B0001003000000_00 +FECF5EC6 C1730A13A0000000_00 +FFFFFF00 C070000000000000_00 +1FF00002 41BFF00002000000_00 +F6DB786B C1A2490F2A000000_00 +FFFFFF80 C060000000000000_00 +F0000FBE C1AFFFE084000000_00 +00000009 4022000000000000_00 +FFFFFFC0 C050000000000000_00 +0010801F 4130801F00000000_00 +0001F238 40FF238000000000_00 +FFFFFFE0 C040000000000000_00 +F8000047 C19FFFFEE4000000_00 +0002133C 410099E000000000_00 +FFFFFFF0 C030000000000000_00 +003C001F 414E000F80000000_00 +000001F1 407F100000000000_00 +FFFFFFF8 C020000000000000_00 +FFDFBFFF C140200080000000_00 +FF5E507F C16435F020000000_00 +FFFFFFFC C010000000000000_00 +037FFFDE 418BFFFEF0000000_00 +FFFD7C6F C1041C8800000000_00 +FFFFFFFE C000000000000000_00 +000000FD 406FA00000000000_00 +FFFFF42A C0A7AC0000000000_00 +FFFFFFFF BFF0000000000000_00 +021FFF7D 4180FFFBE8000000_00 +0000000A 4024000000000000_00 +FFFFFFFD C008000000000000_00 +4010FFFF 41D0043FFFC00000_00 +FFFFFFD3 C046800000000000_00 +FFFFFFFB C014000000000000_00 +FFFF800B C0DFFD4000000000_00 +000000B8 4067000000000000_00 +FFFFFFF7 C022000000000000_00 +FF800803 C15FFDFF40000000_00 +FFFFFFFE C000000000000000_00 +FFFFFFEF C031000000000000_00 +00803FFB 416007FF60000000_00 +00000308 4088400000000000_00 +FFFFFFDF C040800000000000_00 +2107FFFE 41C083FFFF000000_00 +FFE15D4F C13EA2B100000000_00 +FFFFFFBF C050400000000000_00 +400087FD 41D00021FF400000_00 +0000000F 402E000000000000_00 +FFFFFF7F C060200000000000_00 +FDFC007E C1801FFC10000000_00 +00000006 4018000000000000_00 +FFFFFEFF C070100000000000_00 +FFF80100 C11FFC0000000000_00 +FFFFFE99 C076700000000000_00 +FFFFFDFF C080080000000000_00 +03000002 4188000010000000_00 +FFF716EA C121D22C00000000_00 +FFFFFBFF C090040000000000_00 +C7FDFFFF C1CC010000800000_00 +FFFFE327 C0BCD90000000000_00 +FFFFF7FF C0A0020000000000_00 +0103DFFE 41703DFFE0000000_00 +07661FD8 419D987F60000000_00 +FFFFEFFF C0B0010000000000_00 +83FFFFFE C1DF000000800000_00 +FCD956DB C189354928000000_00 +FFFFDFFF C0C0008000000000_00 +FF2001FD C16BFFC060000000_00 +E4D35BBF C1BB2CA441000000_00 +FFFFBFFF C0D0004000000000_00 +DFEFEFFE C1C0080801000000_00 +05DA4300 4197690C00000000_00 +FFFF7FFF C0E0002000000000_00 +40001040 41D0000410000000_00 +812EDF40 C1DFB44830000000_00 +FFFEFFFF C0F0001000000000_00 +FFFFC007 C0CFFC8000000000_00 +00B6FCC9 4166DF9920000000_00 +FFFDFFFF C100000800000000_00 +000007FE 409FF80000000000_00 +FC3DE950 C18E10B580000000_00 +FFFBFFFF C110000400000000_00 +7FFFFE03 41DFFFFF80C00000_00 +FEB02B59 C174FD4A70000000_00 +FFF7FFFF C120000200000000_00 +10FF7FFF 41B0FF7FFF000000_00 +00008D5E 40E1ABC000000000_00 +FFEFFFFF C130000100000000_00 +FFFF007E C0EFF04000000000_00 +001C2108 413C210800000000_00 +FFDFFFFF C140000080000000_00 +00FFC001 416FF80020000000_00 +F01C6B36 C1AFC72994000000_00 +FFBFFFFF C150000040000000_00 +FFFF7FFF C0E0002000000000_00 +FFFFD055 C0C7D58000000000_00 +FF7FFFFF C160000020000000_00 +027BFFFE 4183DFFFF0000000_00 +FF3090D0 C169EDE600000000_00 +FEFFFFFF C170000010000000_00 +00082040 4120408000000000_00 +0000006E 405B800000000000_00 +FDFFFFFF C180000008000000_00 +FDFFFF87 C1800003C8000000_00 +04C3764D 41930DD934000000_00 +FBFFFFFF C190000004000000_00 +0006007E 411801F800000000_00 +000001EF 407EF00000000000_00 +F7FFFFFF C1A0000002000000_00 +FFBF7FFE C150200080000000_00 +FF1C4E5A C16C7634C0000000_00 +EFFFFFFF C1B0000001000000_00 +FFF97FFD C11A000C00000000_00 +000001D1 407D100000000000_00 +DFFFFFFF C1C0000000800000_00 +2FFFFFFE 41C7FFFFFF000000_00 +00136721 4133672100000000_00 +BFFFFFFF C1D0000000400000_00 +00004BFF 40D2FFC000000000_00 +00000544 4095100000000000_00 +7FFFFFFF 41DFFFFFFFC00000_00 +007FDFFB 415FF7FEC0000000_00 +FFF8BD5E C11D0A8800000000_00 +3FFFFFFF 41CFFFFFFF800000_00 +FFBF8003 C1501FFF40000000_00 +FFFE45D2 C0FBA2E000000000_00 +1FFFFFFF 41BFFFFFFF000000_00 +FFFFFDBF C082080000000000_00 +FFFFF189 C0ACEE0000000000_00 +0FFFFFFF 41AFFFFFFE000000_00 +FFFE6FFE C0F9002000000000_00 +FC8672A0 C18BCC6B00000000_00 +07FFFFFF 419FFFFFFC000000_00 +00000107 4070700000000000_00 +FFFCCA70 C109AC8000000000_00 +03FFFFFF 418FFFFFF8000000_00 +002107FE 414083FF00000000_00 +FFFF48E7 C0E6E32000000000_00 +01FFFFFF 417FFFFFF0000000_00 +F7FDFFEE C1A0040024000000_00 +00000010 4030000000000000_00 +00FFFFFF 416FFFFFE0000000_00 +FFFF01FD C0EFC06000000000_00 +0000FAEF 40EF5DE000000000_00 +007FFFFF 415FFFFFC0000000_00 +00FC0001 416F800020000000_00 +000000F5 406EA00000000000_00 +003FFFFF 414FFFFF80000000_00 +FFE07FC0 C13F804000000000_00 +001AFFFB 413AFFFB00000000_00 +001FFFFF 413FFFFF00000000_00 +00101FFD 41301FFD00000000_00 +FF4613B2 C1673D89C0000000_00 +000FFFFF 412FFFFE00000000_00 +F00005FE C1AFFFF404000000_00 +00036402 410B201000000000_00 +0007FFFF 411FFFFC00000000_00 +0404FFFF 419013FFFC000000_00 +021C2358 4180E11AC0000000_00 +0003FFFF 410FFFF800000000_00 +FFFFFD02 C087F00000000000_00 +FFFF41C6 C0E7C74000000000_00 +0001FFFF 40FFFFF000000000_00 +00000007 401C000000000000_00 +27F174DE 41C3F8BA6F000000_00 +0000FFFF 40EFFFE000000000_00 +000083F5 40E07EA000000000_00 +FFFFFFFB C014000000000000_00 +00007FFF 40DFFFC000000000_00 +FE7FDFFE C178020020000000_00 +FFFFFFFD C008000000000000_00 +00003FFF 40CFFF8000000000_00 +DBBFFFFE C1C2200001000000_00 +00000404 4090100000000000_00 +00001FFF 40BFFF0000000000_00 +FFFFC018 C0CFF40000000000_00 +00002853 40C4298000000000_00 +00000FFF 40AFFE0000000000_00 +03FE007F 418FF003F8000000_00 +FFFFF124 C0ADB80000000000_00 +000007FF 409FFC0000000000_00 +FFFFEFBE C0B0420000000000_00 +FFFB9AD8 C11194A000000000_00 +000003FF 408FF80000000000_00 +DFFFFDFE C1C0000101000000_00 +FFFFFD95 C083580000000000_00 +000001FF 407FF00000000000_00 +FDFFFFFF C180000008000000_00 +FFFFFFD0 C048000000000000_00 +000000FF 406FE00000000000_00 +0037FFE0 414BFFF000000000_00 +010EC496 4170EC4960000000_00 +0000007F 405FC00000000000_00 +B8007FFF C1D1FFE000400000_00 +00000012 4032000000000000_00 +0000003F 404F800000000000_00 +02003FFC 418001FFE0000000_00 +FFFFFFEF C031000000000000_00 +0000001F 403F000000000000_00 +FF7FFF02 C160001FC0000000_00 +FFFFE2CE C0BD320000000000_00 +0000000F 402E000000000000_00 +0000A00D 40E401A000000000_00 +FFFFFE44 C07BC00000000000_00 +00000007 401C000000000000_00 +0003FFFA 410FFFD000000000_00 +000038E7 40CC738000000000_00 +00000003 4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_ru.tv b/wally-pipelined/testbench/fp/i32_f64_ru.tv new file mode 100644 index 000000000..7f04b63fd --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f64_ru.tv @@ -0,0 +1,372 @@ +1FEFFFEF 41BFEFFFEF000000_00 +FFFFC48E C0CDB90000000000_00 +00000000 0000000000000000_00 +007FFFCD 415FFFF340000000_00 +00009E14 40E3C28000000000_00 +00000001 3FF0000000000000_00 +001FFFFB 413FFFFB00000000_00 +FFFFDE38 C0C0E40000000000_00 +00000002 4000000000000000_00 +FFDFFC02 C14001FF00000000_00 +FB794C79 C1921ACE1C000000_00 +00000004 4010000000000000_00 +F00FFFFE C1AFE00004000000_00 +00000A95 40A52A0000000000_00 +00000008 4020000000000000_00 +FFFFF97F C09A040000000000_00 +FFAE458D C1546E9CC0000000_00 +00000010 4030000000000000_00 +0101001E 41701001E0000000_00 +29EB4561 41C4F5A2B0800000_00 +00000020 4040000000000000_00 +8001FFEE C1DFFF8004800000_00 +FFFBDD08 C1108BE000000000_00 +00000040 4050000000000000_00 +FFF03FF9 C12F800E00000000_00 +FFCEDF36 C148906500000000_00 +00000080 4060000000000000_00 +0000F01F 40EE03E000000000_00 +00000279 4083C80000000000_00 +00000100 4070000000000000_00 +BFFFFFEF C1D0000004400000_00 +00000007 401C000000000000_00 +00000200 4080000000000000_00 +010BFFFD 4170BFFFD0000000_00 +FFFFF590 C0A4E00000000000_00 +00000400 4090000000000000_00 +F7FFFEFB C1A000020A000000_00 +2FEA335F 41C7F519AF800000_00 +00000800 40A0000000000000_00 +FFC07FFF C14FC00080000000_00 +177957FD 41B77957FD000000_00 +00001000 40B0000000000000_00 +01FBFFEE 417FBFFEE0000000_00 +FFFFFAC9 C094DC0000000000_00 +00002000 40C0000000000000_00 +FFFF8004 C0DFFF0000000000_00 +FFFBE0DE C1107C8800000000_00 +00004000 40D0000000000000_00 +3F00001E 41CF80000F000000_00 +00000000 0000000000000000_00 +00008000 40E0000000000000_00 +FF8201FF C15F7F8040000000_00 +FFFFD2F1 C0C6878000000000_00 +00010000 40F0000000000000_00 +0000047E 4091F80000000000_00 +0011B7E5 4131B7E500000000_00 +00020000 4100000000000000_00 +02200200 4181001000000000_00 +0013F7E6 4133F7E600000000_00 +00040000 4110000000000000_00 +FFFDC007 C101FFC800000000_00 +FD0ABD9A C187AA1330000000_00 +00080000 4120000000000000_00 +0000607F 40D81FC000000000_00 +00003CEE 40CE770000000000_00 +00100000 4130000000000000_00 +DFDFE000 C1C0101000000000_00 +FFFB1642 C113A6F800000000_00 +00200000 4140000000000000_00 +FC000078 C18FFFFC40000000_00 +5F70EEC1 41D7DC3BB0400000_00 +00400000 4150000000000000_00 +00100082 4130008200000000_00 +FFFFFE21 C07DF00000000000_00 +00800000 4160000000000000_00 +FF7BFF7F C160801020000000_00 +FFFF6393 C0E38DA000000000_00 +01000000 4170000000000000_00 +07EFFEFD 419FBFFBF4000000_00 +FFFFFDB4 C082600000000000_00 +02000000 4180000000000000_00 +8002FFFF C1DFFF4000400000_00 +FFFFC8E2 C0CB8F0000000000_00 +04000000 4190000000000000_00 +FFFC0DFE C10F901000000000_00 +FFFFFF1B C06CA00000000000_00 +08000000 41A0000000000000_00 +03FFFDBF 418FFFEDF8000000_00 +0001092B 40F092B000000000_00 +10000000 41B0000000000000_00 +007FBFFD 415FEFFF40000000_00 +00B4F3D1 41669E7A20000000_00 +20000000 41C0000000000000_00 +FEF801FF C1707FE010000000_00 +00000005 4014000000000000_00 +40000000 41D0000000000000_00 +BFF3FFFE C1D0030000800000_00 +0001806B 40F806B000000000_00 +80000000 C1E0000000000000_00 +0000A07E 40E40FC000000000_00 +FFFFA59F C0D6984000000000_00 +C0000000 C1D0000000000000_00 +E0007FDE C1BFFF8022000000_00 +FFF8343E C11F2F0800000000_00 +E0000000 C1C0000000000000_00 +0000FF7C 40EFEF8000000000_00 +FFFFFFF7 C022000000000000_00 +F0000000 C1B0000000000000_00 +BDFFFFFC C1D0800001000000_00 +FFFFE3C1 C0BC3F0000000000_00 +F8000000 C1A0000000000000_00 +28003FFE 41C4001FFF000000_00 +00000000 0000000000000000_00 +FC000000 C190000000000000_00 +00EEFFFF 416DDFFFE0000000_00 +00003EB0 40CF580000000000_00 +FE000000 C180000000000000_00 +00000F7D 40AEFA0000000000_00 +FFFFFF0F C06E200000000000_00 +FF000000 C170000000000000_00 +0000406D 40D01B4000000000_00 +0000001A 403A000000000000_00 +FF800000 C160000000000000_00 +203FFFFD 41C01FFFFE800000_00 +0000000A 4024000000000000_00 +FFC00000 C150000000000000_00 +FFFF007C C0EFF08000000000_00 +0000009B 4063600000000000_00 +FFE00000 C140000000000000_00 +00E00FFF 416C01FFE0000000_00 +00000006 4018000000000000_00 +FFF00000 C130000000000000_00 +00200FFC 414007FE00000000_00 +00000714 409C500000000000_00 +FFF80000 C120000000000000_00 +F800040E C19FFFEFC8000000_00 +00000013 4033000000000000_00 +FFFC0000 C110000000000000_00 +F83BFFFF C19F100004000000_00 +FFF3F584 C12814F800000000_00 +FFFE0000 C100000000000000_00 +F6FFFBFF C1A2000802000000_00 +FFFFFFF0 C030000000000000_00 +FFFF0000 C0F0000000000000_00 +80003FFD C1DFFFF000C00000_00 +FFFFFFAD C054C00000000000_00 +FFFF8000 C0E0000000000000_00 +004001FD 4150007F40000000_00 +000D734E 412AE69C00000000_00 +FFFFC000 C0D0000000000000_00 +006003FE 415800FF80000000_00 +FF9DBAA8 C158915600000000_00 +FFFFE000 C0C0000000000000_00 +000403EE 41100FB800000000_00 +00734668 415CD19A00000000_00 +FFFFF000 C0B0000000000000_00 +01200002 4172000020000000_00 +FF8874A5 C15DE2D6C0000000_00 +FFFFF800 C0A0000000000000_00 +00060001 4118000400000000_00 +FFFFFFF8 C020000000000000_00 +FFFFFC00 C090000000000000_00 +001FFEDD 413FFEDD00000000_00 +FFFC56DF C10D490800000000_00 +FFFFFE00 C080000000000000_00 +EFFFEFFD C1B0001003000000_00 +FECF5EC6 C1730A13A0000000_00 +FFFFFF00 C070000000000000_00 +1FF00002 41BFF00002000000_00 +F6DB786B C1A2490F2A000000_00 +FFFFFF80 C060000000000000_00 +F0000FBE C1AFFFE084000000_00 +00000009 4022000000000000_00 +FFFFFFC0 C050000000000000_00 +0010801F 4130801F00000000_00 +0001F238 40FF238000000000_00 +FFFFFFE0 C040000000000000_00 +F8000047 C19FFFFEE4000000_00 +0002133C 410099E000000000_00 +FFFFFFF0 C030000000000000_00 +003C001F 414E000F80000000_00 +000001F1 407F100000000000_00 +FFFFFFF8 C020000000000000_00 +FFDFBFFF C140200080000000_00 +FF5E507F C16435F020000000_00 +FFFFFFFC C010000000000000_00 +037FFFDE 418BFFFEF0000000_00 +FFFD7C6F C1041C8800000000_00 +FFFFFFFE C000000000000000_00 +000000FD 406FA00000000000_00 +FFFFF42A C0A7AC0000000000_00 +FFFFFFFF BFF0000000000000_00 +021FFF7D 4180FFFBE8000000_00 +0000000A 4024000000000000_00 +FFFFFFFD C008000000000000_00 +4010FFFF 41D0043FFFC00000_00 +FFFFFFD3 C046800000000000_00 +FFFFFFFB C014000000000000_00 +FFFF800B C0DFFD4000000000_00 +000000B8 4067000000000000_00 +FFFFFFF7 C022000000000000_00 +FF800803 C15FFDFF40000000_00 +FFFFFFFE C000000000000000_00 +FFFFFFEF C031000000000000_00 +00803FFB 416007FF60000000_00 +00000308 4088400000000000_00 +FFFFFFDF C040800000000000_00 +2107FFFE 41C083FFFF000000_00 +FFE15D4F C13EA2B100000000_00 +FFFFFFBF C050400000000000_00 +400087FD 41D00021FF400000_00 +0000000F 402E000000000000_00 +FFFFFF7F C060200000000000_00 +FDFC007E C1801FFC10000000_00 +00000006 4018000000000000_00 +FFFFFEFF C070100000000000_00 +FFF80100 C11FFC0000000000_00 +FFFFFE99 C076700000000000_00 +FFFFFDFF C080080000000000_00 +03000002 4188000010000000_00 +FFF716EA C121D22C00000000_00 +FFFFFBFF C090040000000000_00 +C7FDFFFF C1CC010000800000_00 +FFFFE327 C0BCD90000000000_00 +FFFFF7FF C0A0020000000000_00 +0103DFFE 41703DFFE0000000_00 +07661FD8 419D987F60000000_00 +FFFFEFFF C0B0010000000000_00 +83FFFFFE C1DF000000800000_00 +FCD956DB C189354928000000_00 +FFFFDFFF C0C0008000000000_00 +FF2001FD C16BFFC060000000_00 +E4D35BBF C1BB2CA441000000_00 +FFFFBFFF C0D0004000000000_00 +DFEFEFFE C1C0080801000000_00 +05DA4300 4197690C00000000_00 +FFFF7FFF C0E0002000000000_00 +40001040 41D0000410000000_00 +812EDF40 C1DFB44830000000_00 +FFFEFFFF C0F0001000000000_00 +FFFFC007 C0CFFC8000000000_00 +00B6FCC9 4166DF9920000000_00 +FFFDFFFF C100000800000000_00 +000007FE 409FF80000000000_00 +FC3DE950 C18E10B580000000_00 +FFFBFFFF C110000400000000_00 +7FFFFE03 41DFFFFF80C00000_00 +FEB02B59 C174FD4A70000000_00 +FFF7FFFF C120000200000000_00 +10FF7FFF 41B0FF7FFF000000_00 +00008D5E 40E1ABC000000000_00 +FFEFFFFF C130000100000000_00 +FFFF007E C0EFF04000000000_00 +001C2108 413C210800000000_00 +FFDFFFFF C140000080000000_00 +00FFC001 416FF80020000000_00 +F01C6B36 C1AFC72994000000_00 +FFBFFFFF C150000040000000_00 +FFFF7FFF C0E0002000000000_00 +FFFFD055 C0C7D58000000000_00 +FF7FFFFF C160000020000000_00 +027BFFFE 4183DFFFF0000000_00 +FF3090D0 C169EDE600000000_00 +FEFFFFFF C170000010000000_00 +00082040 4120408000000000_00 +0000006E 405B800000000000_00 +FDFFFFFF C180000008000000_00 +FDFFFF87 C1800003C8000000_00 +04C3764D 41930DD934000000_00 +FBFFFFFF C190000004000000_00 +0006007E 411801F800000000_00 +000001EF 407EF00000000000_00 +F7FFFFFF C1A0000002000000_00 +FFBF7FFE C150200080000000_00 +FF1C4E5A C16C7634C0000000_00 +EFFFFFFF C1B0000001000000_00 +FFF97FFD C11A000C00000000_00 +000001D1 407D100000000000_00 +DFFFFFFF C1C0000000800000_00 +2FFFFFFE 41C7FFFFFF000000_00 +00136721 4133672100000000_00 +BFFFFFFF C1D0000000400000_00 +00004BFF 40D2FFC000000000_00 +00000544 4095100000000000_00 +7FFFFFFF 41DFFFFFFFC00000_00 +007FDFFB 415FF7FEC0000000_00 +FFF8BD5E C11D0A8800000000_00 +3FFFFFFF 41CFFFFFFF800000_00 +FFBF8003 C1501FFF40000000_00 +FFFE45D2 C0FBA2E000000000_00 +1FFFFFFF 41BFFFFFFF000000_00 +FFFFFDBF C082080000000000_00 +FFFFF189 C0ACEE0000000000_00 +0FFFFFFF 41AFFFFFFE000000_00 +FFFE6FFE C0F9002000000000_00 +FC8672A0 C18BCC6B00000000_00 +07FFFFFF 419FFFFFFC000000_00 +00000107 4070700000000000_00 +FFFCCA70 C109AC8000000000_00 +03FFFFFF 418FFFFFF8000000_00 +002107FE 414083FF00000000_00 +FFFF48E7 C0E6E32000000000_00 +01FFFFFF 417FFFFFF0000000_00 +F7FDFFEE C1A0040024000000_00 +00000010 4030000000000000_00 +00FFFFFF 416FFFFFE0000000_00 +FFFF01FD C0EFC06000000000_00 +0000FAEF 40EF5DE000000000_00 +007FFFFF 415FFFFFC0000000_00 +00FC0001 416F800020000000_00 +000000F5 406EA00000000000_00 +003FFFFF 414FFFFF80000000_00 +FFE07FC0 C13F804000000000_00 +001AFFFB 413AFFFB00000000_00 +001FFFFF 413FFFFF00000000_00 +00101FFD 41301FFD00000000_00 +FF4613B2 C1673D89C0000000_00 +000FFFFF 412FFFFE00000000_00 +F00005FE C1AFFFF404000000_00 +00036402 410B201000000000_00 +0007FFFF 411FFFFC00000000_00 +0404FFFF 419013FFFC000000_00 +021C2358 4180E11AC0000000_00 +0003FFFF 410FFFF800000000_00 +FFFFFD02 C087F00000000000_00 +FFFF41C6 C0E7C74000000000_00 +0001FFFF 40FFFFF000000000_00 +00000007 401C000000000000_00 +27F174DE 41C3F8BA6F000000_00 +0000FFFF 40EFFFE000000000_00 +000083F5 40E07EA000000000_00 +FFFFFFFB C014000000000000_00 +00007FFF 40DFFFC000000000_00 +FE7FDFFE C178020020000000_00 +FFFFFFFD C008000000000000_00 +00003FFF 40CFFF8000000000_00 +DBBFFFFE C1C2200001000000_00 +00000404 4090100000000000_00 +00001FFF 40BFFF0000000000_00 +FFFFC018 C0CFF40000000000_00 +00002853 40C4298000000000_00 +00000FFF 40AFFE0000000000_00 +03FE007F 418FF003F8000000_00 +FFFFF124 C0ADB80000000000_00 +000007FF 409FFC0000000000_00 +FFFFEFBE C0B0420000000000_00 +FFFB9AD8 C11194A000000000_00 +000003FF 408FF80000000000_00 +DFFFFDFE C1C0000101000000_00 +FFFFFD95 C083580000000000_00 +000001FF 407FF00000000000_00 +FDFFFFFF C180000008000000_00 +FFFFFFD0 C048000000000000_00 +000000FF 406FE00000000000_00 +0037FFE0 414BFFF000000000_00 +010EC496 4170EC4960000000_00 +0000007F 405FC00000000000_00 +B8007FFF C1D1FFE000400000_00 +00000012 4032000000000000_00 +0000003F 404F800000000000_00 +02003FFC 418001FFE0000000_00 +FFFFFFEF C031000000000000_00 +0000001F 403F000000000000_00 +FF7FFF02 C160001FC0000000_00 +FFFFE2CE C0BD320000000000_00 +0000000F 402E000000000000_00 +0000A00D 40E401A000000000_00 +FFFFFE44 C07BC00000000000_00 +00000007 401C000000000000_00 +0003FFFA 410FFFD000000000_00 +000038E7 40CC738000000000_00 +00000003 4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_rz.tv b/wally-pipelined/testbench/fp/i32_f64_rz.tv new file mode 100644 index 000000000..7f04b63fd --- /dev/null +++ b/wally-pipelined/testbench/fp/i32_f64_rz.tv @@ -0,0 +1,372 @@ +1FEFFFEF 41BFEFFFEF000000_00 +FFFFC48E C0CDB90000000000_00 +00000000 0000000000000000_00 +007FFFCD 415FFFF340000000_00 +00009E14 40E3C28000000000_00 +00000001 3FF0000000000000_00 +001FFFFB 413FFFFB00000000_00 +FFFFDE38 C0C0E40000000000_00 +00000002 4000000000000000_00 +FFDFFC02 C14001FF00000000_00 +FB794C79 C1921ACE1C000000_00 +00000004 4010000000000000_00 +F00FFFFE C1AFE00004000000_00 +00000A95 40A52A0000000000_00 +00000008 4020000000000000_00 +FFFFF97F C09A040000000000_00 +FFAE458D C1546E9CC0000000_00 +00000010 4030000000000000_00 +0101001E 41701001E0000000_00 +29EB4561 41C4F5A2B0800000_00 +00000020 4040000000000000_00 +8001FFEE C1DFFF8004800000_00 +FFFBDD08 C1108BE000000000_00 +00000040 4050000000000000_00 +FFF03FF9 C12F800E00000000_00 +FFCEDF36 C148906500000000_00 +00000080 4060000000000000_00 +0000F01F 40EE03E000000000_00 +00000279 4083C80000000000_00 +00000100 4070000000000000_00 +BFFFFFEF C1D0000004400000_00 +00000007 401C000000000000_00 +00000200 4080000000000000_00 +010BFFFD 4170BFFFD0000000_00 +FFFFF590 C0A4E00000000000_00 +00000400 4090000000000000_00 +F7FFFEFB C1A000020A000000_00 +2FEA335F 41C7F519AF800000_00 +00000800 40A0000000000000_00 +FFC07FFF C14FC00080000000_00 +177957FD 41B77957FD000000_00 +00001000 40B0000000000000_00 +01FBFFEE 417FBFFEE0000000_00 +FFFFFAC9 C094DC0000000000_00 +00002000 40C0000000000000_00 +FFFF8004 C0DFFF0000000000_00 +FFFBE0DE C1107C8800000000_00 +00004000 40D0000000000000_00 +3F00001E 41CF80000F000000_00 +00000000 0000000000000000_00 +00008000 40E0000000000000_00 +FF8201FF C15F7F8040000000_00 +FFFFD2F1 C0C6878000000000_00 +00010000 40F0000000000000_00 +0000047E 4091F80000000000_00 +0011B7E5 4131B7E500000000_00 +00020000 4100000000000000_00 +02200200 4181001000000000_00 +0013F7E6 4133F7E600000000_00 +00040000 4110000000000000_00 +FFFDC007 C101FFC800000000_00 +FD0ABD9A C187AA1330000000_00 +00080000 4120000000000000_00 +0000607F 40D81FC000000000_00 +00003CEE 40CE770000000000_00 +00100000 4130000000000000_00 +DFDFE000 C1C0101000000000_00 +FFFB1642 C113A6F800000000_00 +00200000 4140000000000000_00 +FC000078 C18FFFFC40000000_00 +5F70EEC1 41D7DC3BB0400000_00 +00400000 4150000000000000_00 +00100082 4130008200000000_00 +FFFFFE21 C07DF00000000000_00 +00800000 4160000000000000_00 +FF7BFF7F C160801020000000_00 +FFFF6393 C0E38DA000000000_00 +01000000 4170000000000000_00 +07EFFEFD 419FBFFBF4000000_00 +FFFFFDB4 C082600000000000_00 +02000000 4180000000000000_00 +8002FFFF C1DFFF4000400000_00 +FFFFC8E2 C0CB8F0000000000_00 +04000000 4190000000000000_00 +FFFC0DFE C10F901000000000_00 +FFFFFF1B C06CA00000000000_00 +08000000 41A0000000000000_00 +03FFFDBF 418FFFEDF8000000_00 +0001092B 40F092B000000000_00 +10000000 41B0000000000000_00 +007FBFFD 415FEFFF40000000_00 +00B4F3D1 41669E7A20000000_00 +20000000 41C0000000000000_00 +FEF801FF C1707FE010000000_00 +00000005 4014000000000000_00 +40000000 41D0000000000000_00 +BFF3FFFE C1D0030000800000_00 +0001806B 40F806B000000000_00 +80000000 C1E0000000000000_00 +0000A07E 40E40FC000000000_00 +FFFFA59F C0D6984000000000_00 +C0000000 C1D0000000000000_00 +E0007FDE C1BFFF8022000000_00 +FFF8343E C11F2F0800000000_00 +E0000000 C1C0000000000000_00 +0000FF7C 40EFEF8000000000_00 +FFFFFFF7 C022000000000000_00 +F0000000 C1B0000000000000_00 +BDFFFFFC C1D0800001000000_00 +FFFFE3C1 C0BC3F0000000000_00 +F8000000 C1A0000000000000_00 +28003FFE 41C4001FFF000000_00 +00000000 0000000000000000_00 +FC000000 C190000000000000_00 +00EEFFFF 416DDFFFE0000000_00 +00003EB0 40CF580000000000_00 +FE000000 C180000000000000_00 +00000F7D 40AEFA0000000000_00 +FFFFFF0F C06E200000000000_00 +FF000000 C170000000000000_00 +0000406D 40D01B4000000000_00 +0000001A 403A000000000000_00 +FF800000 C160000000000000_00 +203FFFFD 41C01FFFFE800000_00 +0000000A 4024000000000000_00 +FFC00000 C150000000000000_00 +FFFF007C C0EFF08000000000_00 +0000009B 4063600000000000_00 +FFE00000 C140000000000000_00 +00E00FFF 416C01FFE0000000_00 +00000006 4018000000000000_00 +FFF00000 C130000000000000_00 +00200FFC 414007FE00000000_00 +00000714 409C500000000000_00 +FFF80000 C120000000000000_00 +F800040E C19FFFEFC8000000_00 +00000013 4033000000000000_00 +FFFC0000 C110000000000000_00 +F83BFFFF C19F100004000000_00 +FFF3F584 C12814F800000000_00 +FFFE0000 C100000000000000_00 +F6FFFBFF C1A2000802000000_00 +FFFFFFF0 C030000000000000_00 +FFFF0000 C0F0000000000000_00 +80003FFD C1DFFFF000C00000_00 +FFFFFFAD C054C00000000000_00 +FFFF8000 C0E0000000000000_00 +004001FD 4150007F40000000_00 +000D734E 412AE69C00000000_00 +FFFFC000 C0D0000000000000_00 +006003FE 415800FF80000000_00 +FF9DBAA8 C158915600000000_00 +FFFFE000 C0C0000000000000_00 +000403EE 41100FB800000000_00 +00734668 415CD19A00000000_00 +FFFFF000 C0B0000000000000_00 +01200002 4172000020000000_00 +FF8874A5 C15DE2D6C0000000_00 +FFFFF800 C0A0000000000000_00 +00060001 4118000400000000_00 +FFFFFFF8 C020000000000000_00 +FFFFFC00 C090000000000000_00 +001FFEDD 413FFEDD00000000_00 +FFFC56DF C10D490800000000_00 +FFFFFE00 C080000000000000_00 +EFFFEFFD C1B0001003000000_00 +FECF5EC6 C1730A13A0000000_00 +FFFFFF00 C070000000000000_00 +1FF00002 41BFF00002000000_00 +F6DB786B C1A2490F2A000000_00 +FFFFFF80 C060000000000000_00 +F0000FBE C1AFFFE084000000_00 +00000009 4022000000000000_00 +FFFFFFC0 C050000000000000_00 +0010801F 4130801F00000000_00 +0001F238 40FF238000000000_00 +FFFFFFE0 C040000000000000_00 +F8000047 C19FFFFEE4000000_00 +0002133C 410099E000000000_00 +FFFFFFF0 C030000000000000_00 +003C001F 414E000F80000000_00 +000001F1 407F100000000000_00 +FFFFFFF8 C020000000000000_00 +FFDFBFFF C140200080000000_00 +FF5E507F C16435F020000000_00 +FFFFFFFC C010000000000000_00 +037FFFDE 418BFFFEF0000000_00 +FFFD7C6F C1041C8800000000_00 +FFFFFFFE C000000000000000_00 +000000FD 406FA00000000000_00 +FFFFF42A C0A7AC0000000000_00 +FFFFFFFF BFF0000000000000_00 +021FFF7D 4180FFFBE8000000_00 +0000000A 4024000000000000_00 +FFFFFFFD C008000000000000_00 +4010FFFF 41D0043FFFC00000_00 +FFFFFFD3 C046800000000000_00 +FFFFFFFB C014000000000000_00 +FFFF800B C0DFFD4000000000_00 +000000B8 4067000000000000_00 +FFFFFFF7 C022000000000000_00 +FF800803 C15FFDFF40000000_00 +FFFFFFFE C000000000000000_00 +FFFFFFEF C031000000000000_00 +00803FFB 416007FF60000000_00 +00000308 4088400000000000_00 +FFFFFFDF C040800000000000_00 +2107FFFE 41C083FFFF000000_00 +FFE15D4F C13EA2B100000000_00 +FFFFFFBF C050400000000000_00 +400087FD 41D00021FF400000_00 +0000000F 402E000000000000_00 +FFFFFF7F C060200000000000_00 +FDFC007E C1801FFC10000000_00 +00000006 4018000000000000_00 +FFFFFEFF C070100000000000_00 +FFF80100 C11FFC0000000000_00 +FFFFFE99 C076700000000000_00 +FFFFFDFF C080080000000000_00 +03000002 4188000010000000_00 +FFF716EA C121D22C00000000_00 +FFFFFBFF C090040000000000_00 +C7FDFFFF C1CC010000800000_00 +FFFFE327 C0BCD90000000000_00 +FFFFF7FF C0A0020000000000_00 +0103DFFE 41703DFFE0000000_00 +07661FD8 419D987F60000000_00 +FFFFEFFF C0B0010000000000_00 +83FFFFFE C1DF000000800000_00 +FCD956DB C189354928000000_00 +FFFFDFFF C0C0008000000000_00 +FF2001FD C16BFFC060000000_00 +E4D35BBF C1BB2CA441000000_00 +FFFFBFFF C0D0004000000000_00 +DFEFEFFE C1C0080801000000_00 +05DA4300 4197690C00000000_00 +FFFF7FFF C0E0002000000000_00 +40001040 41D0000410000000_00 +812EDF40 C1DFB44830000000_00 +FFFEFFFF C0F0001000000000_00 +FFFFC007 C0CFFC8000000000_00 +00B6FCC9 4166DF9920000000_00 +FFFDFFFF C100000800000000_00 +000007FE 409FF80000000000_00 +FC3DE950 C18E10B580000000_00 +FFFBFFFF C110000400000000_00 +7FFFFE03 41DFFFFF80C00000_00 +FEB02B59 C174FD4A70000000_00 +FFF7FFFF C120000200000000_00 +10FF7FFF 41B0FF7FFF000000_00 +00008D5E 40E1ABC000000000_00 +FFEFFFFF C130000100000000_00 +FFFF007E C0EFF04000000000_00 +001C2108 413C210800000000_00 +FFDFFFFF C140000080000000_00 +00FFC001 416FF80020000000_00 +F01C6B36 C1AFC72994000000_00 +FFBFFFFF C150000040000000_00 +FFFF7FFF C0E0002000000000_00 +FFFFD055 C0C7D58000000000_00 +FF7FFFFF C160000020000000_00 +027BFFFE 4183DFFFF0000000_00 +FF3090D0 C169EDE600000000_00 +FEFFFFFF C170000010000000_00 +00082040 4120408000000000_00 +0000006E 405B800000000000_00 +FDFFFFFF C180000008000000_00 +FDFFFF87 C1800003C8000000_00 +04C3764D 41930DD934000000_00 +FBFFFFFF C190000004000000_00 +0006007E 411801F800000000_00 +000001EF 407EF00000000000_00 +F7FFFFFF C1A0000002000000_00 +FFBF7FFE C150200080000000_00 +FF1C4E5A C16C7634C0000000_00 +EFFFFFFF C1B0000001000000_00 +FFF97FFD C11A000C00000000_00 +000001D1 407D100000000000_00 +DFFFFFFF C1C0000000800000_00 +2FFFFFFE 41C7FFFFFF000000_00 +00136721 4133672100000000_00 +BFFFFFFF C1D0000000400000_00 +00004BFF 40D2FFC000000000_00 +00000544 4095100000000000_00 +7FFFFFFF 41DFFFFFFFC00000_00 +007FDFFB 415FF7FEC0000000_00 +FFF8BD5E C11D0A8800000000_00 +3FFFFFFF 41CFFFFFFF800000_00 +FFBF8003 C1501FFF40000000_00 +FFFE45D2 C0FBA2E000000000_00 +1FFFFFFF 41BFFFFFFF000000_00 +FFFFFDBF C082080000000000_00 +FFFFF189 C0ACEE0000000000_00 +0FFFFFFF 41AFFFFFFE000000_00 +FFFE6FFE C0F9002000000000_00 +FC8672A0 C18BCC6B00000000_00 +07FFFFFF 419FFFFFFC000000_00 +00000107 4070700000000000_00 +FFFCCA70 C109AC8000000000_00 +03FFFFFF 418FFFFFF8000000_00 +002107FE 414083FF00000000_00 +FFFF48E7 C0E6E32000000000_00 +01FFFFFF 417FFFFFF0000000_00 +F7FDFFEE C1A0040024000000_00 +00000010 4030000000000000_00 +00FFFFFF 416FFFFFE0000000_00 +FFFF01FD C0EFC06000000000_00 +0000FAEF 40EF5DE000000000_00 +007FFFFF 415FFFFFC0000000_00 +00FC0001 416F800020000000_00 +000000F5 406EA00000000000_00 +003FFFFF 414FFFFF80000000_00 +FFE07FC0 C13F804000000000_00 +001AFFFB 413AFFFB00000000_00 +001FFFFF 413FFFFF00000000_00 +00101FFD 41301FFD00000000_00 +FF4613B2 C1673D89C0000000_00 +000FFFFF 412FFFFE00000000_00 +F00005FE C1AFFFF404000000_00 +00036402 410B201000000000_00 +0007FFFF 411FFFFC00000000_00 +0404FFFF 419013FFFC000000_00 +021C2358 4180E11AC0000000_00 +0003FFFF 410FFFF800000000_00 +FFFFFD02 C087F00000000000_00 +FFFF41C6 C0E7C74000000000_00 +0001FFFF 40FFFFF000000000_00 +00000007 401C000000000000_00 +27F174DE 41C3F8BA6F000000_00 +0000FFFF 40EFFFE000000000_00 +000083F5 40E07EA000000000_00 +FFFFFFFB C014000000000000_00 +00007FFF 40DFFFC000000000_00 +FE7FDFFE C178020020000000_00 +FFFFFFFD C008000000000000_00 +00003FFF 40CFFF8000000000_00 +DBBFFFFE C1C2200001000000_00 +00000404 4090100000000000_00 +00001FFF 40BFFF0000000000_00 +FFFFC018 C0CFF40000000000_00 +00002853 40C4298000000000_00 +00000FFF 40AFFE0000000000_00 +03FE007F 418FF003F8000000_00 +FFFFF124 C0ADB80000000000_00 +000007FF 409FFC0000000000_00 +FFFFEFBE C0B0420000000000_00 +FFFB9AD8 C11194A000000000_00 +000003FF 408FF80000000000_00 +DFFFFDFE C1C0000101000000_00 +FFFFFD95 C083580000000000_00 +000001FF 407FF00000000000_00 +FDFFFFFF C180000008000000_00 +FFFFFFD0 C048000000000000_00 +000000FF 406FE00000000000_00 +0037FFE0 414BFFF000000000_00 +010EC496 4170EC4960000000_00 +0000007F 405FC00000000000_00 +B8007FFF C1D1FFE000400000_00 +00000012 4032000000000000_00 +0000003F 404F800000000000_00 +02003FFC 418001FFE0000000_00 +FFFFFFEF C031000000000000_00 +0000001F 403F000000000000_00 +FF7FFF02 C160001FC0000000_00 +FFFFE2CE C0BD320000000000_00 +0000000F 402E000000000000_00 +0000A00D 40E401A000000000_00 +FFFFFE44 C07BC00000000000_00 +00000007 401C000000000000_00 +0003FFFA 410FFFD000000000_00 +000038E7 40CC738000000000_00 +00000003 4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_rd.tv b/wally-pipelined/testbench/fp/i64_f32_rd.tv new file mode 100644 index 000000000..9e003f1c2 --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f32_rd.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 5CFFFFBF_01 +0000000032CC8B7A 4E4B322D_01 +0000000000000000 00000000_00 +FFFFFFFFC0003FFE CE7FFF01_01 +032C857F319EDE38 5C4B215F_01 +0000000000000001 3F800000_00 +FFFFFBFFFFF8003E D4800001_01 +00394C79B6D3007B 5A6531E6_01 +0000000000000002 40000000_00 +FBFFFFF0000001FF DC800002_01 +0000000001AE458D 4BD722C6_01 +0000000000000004 40800000_00 +00040008000007FE 58800100_01 +F9EB456140D88764 DCC29754_01 +0000000000000008 41000000_00 +FFFFE400FFFFFFFE D5DFF801_01 +07DE834A248EDF36 5CFBD069_01 +0000000000000010 41800000_00 +00000003FF001FFF 507FC007_01 +FFFFFFFFFFE385E2 C9E3D0F0_00 +0000000000000020 42000000_00 +F0041FFFFFFFFFFF DD7FBE01_01 +000000059EB1FD45 50B3D63F_01 +0000000000000040 42800000_00 +FFFFFFFFFFFCFFF9 C84001C0_00 +FFFFFFFFFFFEDDFE C7910100_00 +0000000000000080 43000000_00 +000000000003FF00 487FC000_00 +00000000C89FF56B 4F489FF5_01 +0000000000000100 43800000_00 +000FFFFF7FDFFFFF 597FFFF7_01 +1B5E4F0BE0DEBFF0 5DDAF278_01 +0000000000000200 44000000_00 +FFFDF803FFFFFFFF D801FF01_01 +FFFFFFFFFFF4766B C9389950_00 +0000000000000400 44800000_00 +0000080100000FFE 55001000_01 +000000000000000C 41400000_00 +0000000000000800 45000000_00 +0048000000100000 5A900000_01 +FFE662A109109D0A D9CCEAF8_01 +0000000000001000 45800000_00 +C000000037FFFFFE DE800000_01 +FFFFFFFFFFFFFFE4 C1E00000_00 +0000000000002000 46000000_00 +F801000000100000 DCFFE000_01 +FE114B79075F70EE DBF75A44_01 +0000000000004000 46800000_00 +100000000001003E 5D800000_01 +00000000000003AC 446B0000_00 +0000000000008000 47000000_00 +200000FFFFFFF800 5E000003_01 +00000044A3A3DBE5 52894747_01 +0000000000010000 47800000_00 +FFE0003EFFFFFFFF D9FFFE09_01 +FFFFFFFFFFFF1A91 C7656F00_00 +0000000000020000 48000000_00 +FFFFF7C3FFFFFFFD D503C001_01 +0000000000003309 464C2400_00 +0000000000040000 48800000_00 +000083FFF7FFFFFE 5703FFF7_01 +FFFFFFFFFFFFFF58 C3280000_00 +0000000000080000 49000000_00 +FFFFFFDE01FFFFFE D207F801_01 +0000000000002980 46260000_00 +0000000000100000 49800000_00 +00000000FFF07FFF 4F7FF07F_01 +000000000000005D 42BA0000_00 +0000000000200000 4A000000_00 +000020FFDFFFFFFF 5603FF7F_01 +FFFC8C23DA2CEAD8 D85CF70A_01 +0000000000400000 4A800000_00 +E0000000003FFFDF DE000000_01 +FFFFFDE3C1DEC43C D4070F89_01 +0000000000800000 4B000000_00 +FFFF00000BFFFFFD D77FFFF5_01 +000000000030FFBE 4A43FEF8_00 +0000000001000000 4B800000_00 +FFFE000007FFEFFD D7FFFFFD_01 +FFFFFFFFEFDEED86 CD810894_01 +0000000002000000 4C000000_00 +F3FFFFFFFFBFFFFE DD400001_01 +000000001DA3FF45 4DED1FFA_01 +0000000004000000 4C800000_00 +FFFFFFFF00010007 CF7FFF00_01 +FFFFFFFE9B1BCB54 CFB2721B_01 +0000000008000000 4D000000_00 +00004000004001FE 56800000_01 +F27DD19DE6563714 DD5822E7_01 +0000000010000000 4D800000_00 +FFC00000004007FE DA800000_01 +000000000001A359 47D1AC80_00 +0000000020000000 4E000000_00 +0000000003C000FE 4C70003F_01 +FFFFFFFFFE62EC20 CBCE89F0_00 +0000000040000000 4E800000_00 +000000003FFFFFFD 4E7FFFFF_01 +000000000000285F 46217C00_00 +0000000080000000 4F000000_00 +FFFFFFFFBFFFF00F CE800020_01 +FFFFF836F99DBAA8 D4F920CD_01 +0000000100000000 4F800000_00 +00000020003FFEFE 520000FF_01 +0033466832042D47 5A4D19A0_01 +0000000200000000 50000000_00 +FFFFFFFFFFFFF887 C4EF2000_00 +00000000003829C8 4A60A720_00 +0000000400000000 50800000_00 +00000FFFFFFF7DFD 557FFFFF_01 +0000000FB77C672B 517B77C6_01 +0000000800000000 51000000_00 +08003FFDFFFFFFFE 5D0003FF_01 +0000000000001B78 45DBC000_00 +0000001000000000 51800000_00 +FF7FFFFFFFEFDFFF DB000001_01 +0000000000000071 42E20000_00 +0000002000000000 52000000_00 +000013FFFFFFFDFF 559FFFFF_01 +FFFFFFFFFFFFFF86 C2F40000_00 +0000004000000000 52800000_00 +0800000000040800 5D000000_01 +FFF8A60D9E19F17E D8EB3E4D_01 +0000008000000000 53000000_00 +000077FFF0000000 56EFFFE0_00 +FFFFFFFFF7506DBA CD0AF925_01 +0000010000000000 53800000_00 +FFFFFFFFFFFEFBF7 C7820480_00 +FFFFFFFFFEA42AC9 CBADEA9C_01 +0000020000000000 54000000_00 +0000107FFFFFDFFD 5583FFFF_01 +FFE7AA3F2BDACC89 D9C2AE07_01 +0000040000000000 54800000_00 +FFF8040000040000 D8FF8000_01 +FFFFFFFFFFFFFFFD C0400000_00 +0000080000000000 55000000_00 +FFFF80000800001F D6FFFFF0_01 +FFFDF681DECDADC9 D8025F89_01 +0000100000000000 55800000_00 +FFFFFEFFFFE0007F D3800010_01 +FFFFFFFFFFFFCFBE C6410800_00 +0000200000000000 56000000_00 +0000000901FFFFFD 51101FFF_01 +FEC01FECA24DE1B0 DB9FF00A_01 +0000400000000000 56800000_00 +F7FFFFFFDFFF7FFF DD000001_01 +F858A66761669936 DCF4EB34_01 +0000800000000000 57000000_00 +FFFEFF800000003E D7804000_01 +F716EA43FAC45C97 DD0E915C_01 +0001000000000000 57800000_00 +FFFFFFFFFFFFFFC6 C2680000_00 +0024D70EC7661FD8 5A135C3B_01 +0002000000000000 58000000_00 +C07FFFFFFFFFFFFE DE7E0001_01 +FFD956DBD0AEE817 DA1AA491_01 +0004000000000000 58800000_00 +020003EFFFFFFFFE 5C0000FB_01 +FFFFFFFFFFFF4300 C73D0000_00 +0008000000000000 59000000_00 +4000000004002000 5E800000_01 +C12EDF40F41F6021 DE7B4483_01 +0010000000000000 59800000_00 +FF9000000000001D DAE00000_01 +FFFFFFF83DE950F6 D0F842D6_01 +0020000000000000 5A000000_00 +800003FFFFFC0000 DEFFFFF9_01 +FE2B59CB3A604D69 DBEA531B_01 +0040000000000000 5A800000_00 +7FFFFFFDFFFFBFFF 5EFFFFFF_01 +000000A37C210862 53237C21_01 +0080000000000000 5B000000_00 +0002000002000002 58000000_01 +FFFFB65CD8617789 D6934650_01 +0100000000000000 5B800000_00 +00001BFFFFFFBFFE 55DFFFFF_01 +FFFFFFFFFFFFF01D C57E3000_00 +0200000000000000 5C000000_00 +1000008000003FFF 5D800004_01 +000000000D098D19 4D5098D1_01 +0400000000000000 5C800000_00 +03FFFFFFFFFFF5FF 5C7FFFFF_01 +000006B3BD2C7BEF 54D677A5_01 +0800000000000000 5D000000_00 +00003FFFBFFFFFFE 567FFEFF_01 +FFFF4E5ADDDAA4A8 D731A523_01 +1000000000000000 5D800000_00 +001FFFC000000FFD 59FFFE00_01 +FFFFFFFFFFFFFF21 C35F0000_00 +2000000000000000 5E000000_00 +0000000041DFFFFF 4E83BFFF_01 +FFFFFFFFFC648262 CC66DF68_01 +4000000000000000 5E800000_00 +C0001FFFFFFFFFFB DE7FFF81_01 +FFFFFF7353AC45D2 D30CAC54_01 +8000000000000000 DF000000_00 +FFFFFFFFFFE7EFFF C9C08008_00 +0000000000A1202D 4B21202D_00 +C000000000000000 DE800000_00 +FFFFFFFFFFFF5F7F C7208100_00 +000000000040CA70 4A8194E0_00 +E000000000000000 DE000000_00 +0000200201FFFFFE 56000807_01 +00000003B55D87D4 506D5761_01 +F000000000000000 DD800000_00 +FF80000DFFFFFFFF DAFFFFE5_01 +000000010510FAEF 4F82887D_01 +F800000000000000 DD000000_00 +0003FFF00000000F 587FFC00_01 +000000000000724A 46E49400_00 +FC00000000000000 DC800000_00 +FFFFFFDF80000002 D2020000_01 +0000000000000064 42C80000_00 +FE00000000000000 DC000000_00 +FEFFFFFFFFF800FE DB800001_01 +FFFFFFC2C6222702 D274E778_01 +FF00000000000000 DB800000_00 +0000000408000002 50810000_01 +000000E96DF1CB41 53696DF1_01 +FF80000000000000 DB000000_00 +007FFFFFFFFFF9FE 5AFFFFFF_01 +F727F174DEE7DC85 DD0D80E9_01 +FFC0000000000000 DA800000_00 +8000000003FFFEFE DF000000_01 +FFFFFFFFFFF0BD5B C9742A50_00 +FFE0000000000000 DA000000_00 +0BEFFFFFFFFFFFFF 5D3EFFFF_01 +000000000002790C 481E4300_00 +FFF0000000000000 D9800000_00 +FFFFFFFFFFEFFBFA C9802030_00 +000000169E75DF01 51B4F3AE_01 +FFF8000000000000 D9000000_00 +00000007FEFFDFFF 50FFDFFB_01 +000000000000000E 41600000_00 +FFFC000000000000 D8800000_00 +0003FFFE0007FFFE 587FFF80_01 +FFFFFFFFFFF28622 C9579DE0_00 +FFFE000000000000 D8000000_00 +FFFFFF7FFFFDF7FF D3000003_01 +00072F0EC496FE21 58E5E1D8_01 +FFFF000000000000 D7800000_00 +DFBFFFFFFFFFFFFE DE010001_01 +0000000000FC1FCA 4B7C1FCA_00 +FFFF800000000000 D7000000_00 +00000FFF800FFFFE 557FF800_01 +FFFF5194E4A9C2CE D72E6B1C_01 +FFFFC00000000000 D6800000_00 +00000002100007FD 50040001_01 +FFFFFFFFFFC2D8FE CA749C08_00 +FFFFE00000000000 D6000000_00 +000000000007FF6E 48FFEDC0_00 +000000000001766E 47BB3700_00 +FFFFF00000000000 D5800000_00 +0040000400000002 5A800008_01 +0000000000007841 46F08200_00 +FFFFF80000000000 D5000000_00 +3DFFFFFFFFFFFF7E 5E77FFFF_01 +FFFFFFE549E17E30 D1D5B0F5_01 +FFFFFC0000000000 D4800000_00 +FFFFFFFFFFFFFEE1 C38F8000_00 +FFFFFFFFFFFFFFE7 C1C80000_00 +FFFFFE0000000000 D4000000_00 +000000000EFFFFDF 4D6FFFFD_01 +FFFFFFFFFFFFFF73 C30D0000_00 +FFFFFF0000000000 D3800000_00 +FD00000008000000 DC400000_01 +000000000001DBB1 47EDD880_00 +FFFFFF8000000000 D3000000_00 +FFFFFFFFFFF8007F C8FFF020_00 +FFFFFFFEFD10A515 CF8177AE_01 +FFFFFFC000000000 D2800000_00 +FFEFFFFFFFFFFFFE D9800001_01 +FAB02984F6283B6C DCA9FAD0_01 +FFFFFFE000000000 D2000000_00 +FFFFFFBC000001FE D2880000_01 +FEB087C6B9FE7FE0 DBA7BC1D_01 +FFFFFFF000000000 D1800000_00 +FFF80001000007FE D8FFFFE0_01 +00F2762EA6837956 5B72762E_01 +FFFFFFF800000000 D1000000_00 +FFF7E0FFFFFFFFFE D901F001_01 +00002E1175484626 563845D5_01 +FFFFFFFC00000000 D0800000_00 +0000200020000FFE 56000080_01 +000000000000068F 44D1E000_00 +FFFFFFFE00000000 D0000000_00 +021FFFFFFFFBFFFF 5C07FFFF_01 +FFFFFFFFFFFFFFF9 C0E00000_00 +FFFFFFFF00000000 CF800000_00 +FFFFFFD0000FFFFD D23FFFC1_01 +000000BDF6658B83 533DF665_01 +FFFFFFFF80000000 CF000000_00 +1000001FFDFFFFFF 5D800000_01 +0000000000003B5B 466D6C00_00 +FFFFFFFFC0000000 CE800000_00 +FFFFFFBFFE0FFFFF D28003E1_01 +FFFFFFFFFFFFFFF0 C1800000_00 +FFFFFFFFE0000000 CE000000_00 +FFFFFFFBF00007FF D0820000_01 +01E986274F48EAAD 5BF4C313_01 +FFFFFFFFF0000000 CD800000_00 +1FFFFFFDFFFFFF7F 5DFFFFFF_01 +FFFFFFFFFFFFCB5A C6529800_00 +FFFFFFFFF8000000 CD000000_00 +7FF000000000FFFF 5EFFE000_01 +00000003C2717FC3 50709C5F_01 +FFFFFFFFFC000000 CC800000_00 +FFFFFFE00008001F D1FFFFC0_01 +FFFFFFFFFFEFABDA C982A130_00 +FFFFFFFFFE000000 CC000000_00 +0200000000000002 5C000000_01 +FFFFFFFFF8FDA53F CCE04B59_01 +FFFFFFFFFF000000 CB800000_00 +F6000003FFFFFFFE DD200000_01 +FFFFFFFFFFFFFFD0 C2400000_00 +FFFFFFFFFF800000 CB000000_00 +FFFFFFFFFFBFFF7E CA800104_00 +00000000EE0FEA62 4F6E0FEA_01 +FFFFFFFFFFC00000 CA800000_00 +0000007FFF9FFFFD 52FFFF3F_01 +00000037F35EDC1D 525FCD7B_01 +FFFFFFFFFFE00000 CA000000_00 +FFFFFFF7FDFFFF7D D1002001_01 +00000000000001AD 43D68000_00 +FFFFFFFFFFF00000 C9800000_00 +FFFFFF0000100020 D37FFFF0_01 +27F167FBC7FC5F9A 5E1FC59F_01 +FFFFFFFFFFF80000 C9000000_00 +003FFFFFFFFC0001 5A7FFFFF_01 +000E48F9F4EBD30E 59648F9F_01 +FFFFFFFFFFFC0000 C8800000_00 +DFFFFFFFFFFBFFFE DE000001_01 +FC91C23EE8C9424F DC5B8F71_01 +FFFFFFFFFFFE0000 C8000000_00 +F7DFFBFFFFFFFFFE DD020041_01 +000000002CAE080C 4E32B820_01 +FFFFFFFFFFFF0000 C7800000_00 +FFFFC00010000020 D67FFFC0_01 +04D921F917B20E40 5C9B243F_01 +FFFFFFFFFFFF8000 C7000000_00 +F8000FFFFFFFFFFD DCFFFE01_01 +FFF17C566BC7D811 D9683A9A_01 +FFFFFFFFFFFFC000 C6800000_00 +00000000000000FE 437E0000_00 +FFF82AC14930D386 D8FAA7D7_01 +FFFFFFFFFFFFE000 C6000000_00 +00000000000003FC 447F0000_00 +000E62EC60E119FC 59662EC6_01 +FFFFFFFFFFFFF000 C5800000_00 +FFFFEFF7FF7FFFFE D5804005_01 +0E2B1ECF210EEDC5 5D62B1EC_01 +FFFFFFFFFFFFF800 C5000000_00 +00000000007FFF1F 4AFFFE3E_00 +FFFFFE534F5676F7 D3D65855_01 +FFFFFFFFFFFFFC00 C4800000_00 +0000001004FFFFFD 518027FF_01 +0000035C939669F1 545724E5_01 +FFFFFFFFFFFFFE00 C4000000_00 +1FFFFFFFFFFFFDFD 5DFFFFFF_01 +FFFFFFFFFFFFFF91 C2DE0000_00 +FFFFFFFFFFFFFF00 C3800000_00 +01FFFFFFFBFFEFFE 5BFFFFFF_01 +000000000000016E 43B70000_00 +FFFFFFFFFFFFFF80 C3000000_00 +FFF7FFFFFFFFF7FD D9000001_01 +FFFFF8E2BCFAC553 D4E3A861_01 +FFFFFFFFFFFFFFC0 C2800000_00 +FFFFFBFFFFFE0FFE D4800001_01 +00000001A4E704BF 4FD27382_01 +FFFFFFFFFFFFFFE0 C2000000_00 +1400007FFFFFFFFD 5DA00003_01 +FFFFFFFC93B187B4 D05B139F_01 +FFFFFFFFFFFFFFF0 C1800000_00 +40000000007FFFFD 5E800000_01 +000000000067D468 4ACFA8D0_00 +FFFFFFFFFFFFFFF8 C1000000_00 +007FFEFFFFFBFFFE 5AFFFDFF_01 +FFFFFFE26CEC79F8 D1EC989D_01 +FFFFFFFFFFFFFFFC C0800000_00 +00FFFFFF000000FF 5B7FFFFF_01 +FFFFFFFFE0D3983A CDF9633F_01 +FFFFFFFFFFFFFFFE C0000000_00 +00007FFFBFFF7FFE 56FFFF7F_01 +FFFFFFFDF4A7088A D002D63E_01 +FFFFFFFFFFFFFFFF BF800000_00 +000008000000027E 55000000_01 +000000000000F4E8 4774E800_00 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFF83FFDF CAF80042_00 +00000E11407887B2 55611407_01 +FFFFFFFFFFFFFFFB C0A00000_00 +04000003FFFFFFF6 5C800000_01 +0000000000000513 44A26000_00 +FFFFFFFFFFFFFFF7 C1100000_00 +BFFC00000000003E DE800800_01 +00000008D7BBB75B 510D7BBB_01 +FFFFFFFFFFFFFFEF C1880000_00 +000FFFFBFFFC0000 597FFFBF_01 +FFFFFFFFFFCD5A23 CA4A9774_00 +FFFFFFFFFFFFFFDF C2040000_00 +FFBFDFFFBFFFFFFF DA804001_01 +000000000000007F 42FE0000_00 +FFFFFFFFFFFFFFBF C2820000_00 +00000007FF800003 50FFF000_01 +000000000002BB02 482EC080_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEE7FF C78C0080_00 +00264B2B9BAD0DA2 5A192CAE_01 +FFFFFFFFFFFFFEFF C3808000_00 +0000000000100803 49804018_00 +FF9B1DCB9F857D5E DAC9C469_01 +FFFFFFFFFFFFFDFF C4004000_00 +FFFFFFBFFFFFEFEE D2800001_01 +F6FD7542899C1C6F DD1028AC_01 +FFFFFFFFFFFFFBFF C4802000_00 +FF800000004001FF DB000000_01 +0000000002BE4932 4C2F924C_01 +FFFFFFFFFFFFF7FF C5001000_00 +00001004000FFFFE 55802000_01 +FFFFFF9DAA0123E0 D2C4ABFE_01 +FFFFFFFFFFFFEFFF C5800800_00 +00000001FDFFFDFE 4FFEFFFE_01 +FFFC1C8703B1DCB0 D878DE40_01 +FFFFFFFFFFFFDFFF C6000400_00 +FE0FE00000000000 DBF81000_00 +0779ED944A4E2779 5CEF3DB2_01 +FFFFFFFFFFFFBFFF C6800200_00 +FBFFFE0400000000 DC800040_01 +0000010127E03666 538093F0_01 +FFFFFFFFFFFF7FFF C7000100_00 +FFFFF0200000FFFE D57E0000_01 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEFFFF C7800080_00 +FFEFFE0000080000 D9801000_01 +FFFFFFFFFD3354EA CC332AC6_01 +FFFFFFFFFFFDFFFF C8000040_00 +003FF0000003FFFE 5A7FC000_01 +0000006375B23F7B 52C6EB64_01 +FFFFFFFFFFFBFFFF C8800020_00 +000407FFFFFFFFF6 5880FFFF_01 +0000000092117F38 4F12117F_01 +FFFFFFFFFFF7FFFF C9000010_00 +FFFFFFFFFFFF7FFF C7000100_00 +00000000000008BE 450BE000_00 +FFFFFFFFFFEFFFFF C9800008_00 +004000020FFFFFFF 5A800004_01 +FFFFB84C2D8BC9CB D68F67A5_01 +FFFFFFFFFFDFFFFF CA000004_00 +00FFFFFFFFFFFFFD 5B7FFFFF_01 +00000023C2C6F284 520F0B1B_01 +FFFFFFFFFFBFFFFF CA800002_00 +FFFDDFFFFFFFFFFD D8080001_01 +00000000746356C4 4EE8C6AD_01 +FFFFFFFFFF7FFFFF CB000001_00 +010000000000BFFF 5B800000_01 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFEFFFFFF CB800001_01 +FFFFBF7FFBFFFFFE D6810009_01 +00000006386CE889 50C70D9D_01 +FFFFFFFFFDFFFFFF CC000001_01 +F00000F7FFFFFFFF DD7FFFF1_01 +FFFDFC53090C46A4 D800EB3E_01 +FFFFFFFFFBFFFFFF CC800001_01 +0000000000800047 4B000047_00 +FFFFFFFFD693872E CE25B1E4_01 +FFFFFFFFF7FFFFFF CD000001_01 +000000007FBFFBFF 4EFF7FF7_01 +00000026A7845E35 521A9E11_01 +FFFFFFFFEFFFFFFF CD800001_01 +FFFFFFDFFFFFFBFD D2000001_01 +000000001433D14C 4DA19E8A_01 +FFFFFFFFDFFFFFFF CE000001_01 +0001FFFFFFE0000E 57FFFFFF_01 +F0F23E8068D3D84A DD70DC18_01 +FFFFFFFFBFFFFFFF CE800001_01 +F7FFBFFFFFFFBFFF DD000401_01 +FFFFBD29B7459087 D685AC92_01 +FFFFFFFF7FFFFFFF CF000001_01 +FFFFFFF8FFFFBFFF D0E00009_01 +FFFFFFFFFFEDDC06 C9911FD0_00 +FFFFFFFEFFFFFFFF CF800001_01 +FFFFFFF80001FFFF D0FFFFC1_01 +0000000000002FF9 463FE400_00 +FFFFFFFDFFFFFFFF D0000001_01 +004000040000FFFF 5A800008_01 +FFFFFFFFFFFFFFF1 C1700000_00 +FFFFFFFBFFFFFFFF D0800001_01 +C0000000007FFFFA DE800000_01 +FFFFFFFFFE053E2B CBFD60EB_01 +FFFFFFF7FFFFFFFF D1000001_01 +7FFE000007FFFFFF 5EFFFC00_01 +000000000000000D 41500000_00 +FFFFFFEFFFFFFFFF D1800001_01 +F80000000001007E DD000000_01 +FFFFED48424AD9D6 D595BDEE_01 +FFFFFFDFFFFFFFFF D2000001_01 +FFFFFE0001FEFFFF D3FFFF01_01 +000000000000013B 439D8000_00 +FFFFFFBFFFFFFFFF D2800001_01 +0007FBFFFFFDFFFE 58FF7FFF_01 +4A16BD4128090C83 5E942D7A_01 +FFFFFF7FFFFFFFFF D3000001_01 +00FFF7FFFF7FFFFE 5B7FF7FF_01 +0000000000000006 40C00000_00 +FFFFFEFFFFFFFFFF D3800001_01 +FBFFFFBFFFBFFFFF DC800009_01 +00000000000001BA 43DD0000_00 +FFFFFDFFFFFFFFFF D4000001_01 +0000000040000082 4E800001_01 +FF07A2BF5B689F89 DB785D41_01 +FFFFFBFFFFFFFFFF D4800001_01 +0000001FF8000008 51FFC000_01 +F87CAA7DE672DE8B DCF06AB1_01 +FFFFF7FFFFFFFFFF D5000001_01 +07FFF80000000002 5CFFFF00_01 +0000000010A1E5B8 4D850F2D_01 +FFFFEFFFFFFFFFFF D5800001_01 +F7FFFFE00007FFFF DD000002_01 +FFFFFFFFFFF6ADFC C9152040_00 +FFFFDFFFFFFFFFFF D6000001_01 +FFFFFF03FFFFFFC0 D37C0001_01 +EA579475948F0032 DDAD435D_01 +FFFFBFFFFFFFFFFF D6800001_01 +FC00000000003FF6 DC800000_01 +002E677AC313BF60 5A399DEB_01 +FFFF7FFFFFFFFFFF D7000001_01 +02000007FF7FFFFF 5C000001_01 +0000000E999639F1 51699963_01 +FFFEFFFFFFFFFFFF D7800001_01 +FFFF83FFFFFFFFBE D6F80001_01 +000000000001537D 47A9BE80_00 +FFFDFFFFFFFFFFFF D8000001_01 +EFFFFFC00000003D DD800002_01 +FFFFFFF21FEDFD35 D15E0121_01 +FFFBFFFFFFFFFFFF D8800001_01 +FFFFFFF0000007FE D1800000_01 +FFFFFFFFFFDE0839 CA07DF1C_00 +FFF7FFFFFFFFFFFF D9000001_01 +0000007FFFE000FF 52FFFFC0_01 +FFFFFFFF79F30F48 CF060CF1_01 +FFEFFFFFFFFFFFFF D9800001_01 +FFFFFC13FFFFFFFD D47B0001_01 +0000000000001B85 45DC2800_00 +FFDFFFFFFFFFFFFF DA000001_01 +000008000007FFFE 55000000_01 +12DB4409E5AE87E6 5D96DA20_01 +FFBFFFFFFFFFFFFF DA800001_01 +FFFFFFFFFFF7BFEE C9040120_00 +FFFFFFFFFFFFFFFD C0400000_00 +FF7FFFFFFFFFFFFF DB000001_01 +000000001040FFFE 4D8207FF_01 +00000909A09C13D3 55109A09_01 +FEFFFFFFFFFFFFFF DB800001_01 +FFFFFF01FFFFFF7F D37E0001_01 +FFFFFF72E7D2575D D30D182E_01 +FDFFFFFFFFFFFFFF DC000001_01 +FFFFFFFFFFFEFFDB C7801280_00 +0000000000000017 41B80000_00 +FBFFFFFFFFFFFFFF DC800001_01 +100000001FFFFFF6 5D800000_01 +000000114B12EF51 518A5897_01 +F7FFFFFFFFFFFFFF DD000001_01 +0407FFFFFFFFFEFF 5C80FFFF_01 +FFFFFF769F3A5C2C D30960C6_01 +EFFFFFFFFFFFFFFF DD800001_01 +FFFFFFFDF7FFFFFD D0020001_01 +FFFFFFFFFFFFFFF2 C1600000_00 +DFFFFFFFFFFFFFFF DE000001_01 +FFFFFFFFFE0007FF CBFFFC01_01 +000000000000001E 41F00000_00 +BFFFFFFFFFFFFFFF DE800001_01 +FFF800000009FFFF D9000000_01 +0000000000007AA4 46F54800_00 +7FFFFFFFFFFFFFFF 5EFFFFFF_01 +4080000000FFFFFF 5E810000_01 +000000000DE7601D 4D5E7601_01 +3FFFFFFFFFFFFFFF 5E7FFFFF_01 +FFCFFFFFFFBFFFFE DA400001_01 +FFFFFFFFFFFFFFCA C2580000_00 +1FFFFFFFFFFFFFFF 5DFFFFFF_01 +000080400000003F 57004000_01 +00000000001F75A5 49FBAD28_00 +0FFFFFFFFFFFFFFF 5D7FFFFF_01 +FFFFFFEFFFFFCFFE D1800002_01 +FFFFFEE775887420 D38C453C_01 +07FFFFFFFFFFFFFF 5CFFFFFF_01 +00000000000801FE 49001FE0_00 +0000000000213FF1 4A04FFC4_00 +03FFFFFFFFFFFFFF 5C7FFFFF_01 +07FEFFFFFFFFFFEE 5CFFDFFF_01 +0000000000000004 40800000_00 +01FFFFFFFFFFFFFF 5BFFFFFF_01 +0000000820000003 51020000_01 +FFFFFFF9AD105214 D0CA5DF6_01 +00FFFFFFFFFFFFFF 5B7FFFFF_01 +FFFFF00FFFFFFFBE D57F0001_01 +FFFFFFFFFFCC48E7 CA4EDC64_00 +007FFFFFFFFFFFFF 5AFFFFFF_01 +00000FFFEF7FFFFF 557FFEF7_01 +FFFFFFFFFF0BA6CB CB745935_00 +003FFFFFFFFFFFFF 5A7FFFFF_01 +FFFFFF7FBFFFFFBF D3004001_01 +FFFFFFFFFFF24425 C95BBDB0_00 +001FFFFFFFFFFFFF 59FFFFFF_01 +200000001FFBFFFF 5E000000_01 +FFFFFF4E7115EC53 D3318EEB_01 +000FFFFFFFFFFFFF 597FFFFF_01 +FFFFF803FFFFFFBF D4FF8001_01 +FFFFFC2E539ADCFE D4746B1A_01 +0007FFFFFFFFFFFF 58FFFFFF_01 +FFFFFFFFFBFFFFFF CC800001_01 +00000055084732F3 52AA108E_01 +0003FFFFFFFFFFFF 587FFFFF_01 +BFFF7FFFFFFFFE00 DE800101_01 +FFFFFFFFFFFF8543 C6F57A00_00 +0001FFFFFFFFFFFF 57FFFFFF_01 +0000001FFBFFE000 51FFDFFF_00 +FFFFFFFFFFFE491B C7DB7280_00 +0000FFFFFFFFFFFF 577FFFFF_01 +FC00200000001FFE DC7FF800_01 +FFFFF16898822A24 D5697678_01 +00007FFFFFFFFFFF 56FFFFFF_01 +3FFF03FFFFFFFFFE 5E7FFC0F_01 +FFFFFF8FFE18C7BF D2E003CF_01 +00003FFFFFFFFFFF 567FFFFF_01 +FFFFFEFFFEFFFFFD D3800081_01 +00F03620C1266ED9 5B703620_01 +00001FFFFFFFFFFF 55FFFFFF_01 +BF7EFFFFFFFFFFFF DE810201_01 +FFFFFFFFFFFFFFD5 C22C0000_00 +00000FFFFFFFFFFF 557FFFFF_01 +FFFBFFFFF803FFFE D8800001_01 +0000000000068684 48D0D080_00 +000007FFFFFFFFFF 54FFFFFF_01 +DFFFFFE00000001E DE000001_01 +FFFFFFFFFFFFECF5 C5985800_00 +000003FFFFFFFFFF 547FFFFF_01 +FFFF00400000FFFF D77FC000_01 +0000000000000002 40000000_00 +000001FFFFFFFFFF 53FFFFFF_01 +FBFFFFFFFFFFBDFE DC800001_01 +0000000000000BC9 453C9000_00 +000000FFFFFFFFFF 537FFFFF_01 +807FFFFFFFFFDFFE DEFF0001_01 +FFC274E35A70CD76 DA762C73_01 +0000007FFFFFFFFF 52FFFFFF_01 +0FFFFFFFFEFFFFFD 5D7FFFFF_01 +FFFFFFFF00E73AFC CF7F18C6_01 +0000003FFFFFFFFF 527FFFFF_01 +FFC000000001000E DA800000_01 +FFFFFFFFFFFE15E9 C7F50B80_00 +0000001FFFFFFFFF 51FFFFFF_01 +0001FFFFFFFFF3FD 57FFFFFF_01 +0000000000000033 424C0000_00 +0000000FFFFFFFFF 517FFFFF_01 +000000001FFFBFFF 4DFFFDFF_01 +FFFFFFEE6B141E1B D18CA760_01 +00000007FFFFFFFF 50FFFFFF_01 +FFFFFFFFF60007FF CD1FFF81_01 +00000001AB310BA6 4FD59885_01 +00000003FFFFFFFF 507FFFFF_01 +0003FFFFB7FFFFFF 587FFFED_01 +FFFFFFFFFFFFF195 C566B000_00 +00000001FFFFFFFF 4FFFFFFF_01 +FFFFFFFF8000000B CF000000_01 +00000019BA8D5559 51CDD46A_01 +00000000FFFFFFFF 4F7FFFFF_01 +FBFEFFFFFFFFFFF9 DC802001_01 +FFFFFFB6F062822D D2921F3B_01 +000000007FFFFFFF 4EFFFFFF_01 +0001000000000082 57800000_01 +01CEAD9E2FB104A4 5BE756CF_01 +000000003FFFFFFF 4E7FFFFF_01 +000003FFFFFFFF7C 547FFFFF_01 +FFFFFFFFFD681E78 CC25F862_00 +000000001FFFFFFF 4DFFFFFF_01 +00002000400001FF 56000100_01 +0000000000000018 41C00000_00 +000000000FFFFFFF 4D7FFFFF_01 +3FFF80000000003E 5E7FFE00_01 +FFFFFFFFFFFFFF95 C2D60000_00 +0000000007FFFFFF 4CFFFFFF_01 +010000BFFFFFFFFF 5B80005F_01 +0000001697087B19 51B4B843_01 +0000000003FFFFFF 4C7FFFFF_01 +FBFFFFFFFFEEFFFD DC800001_01 +0000000E64BDFC55 51664BDF_01 +0000000001FFFFFF 4BFFFFFF_01 +FC00000001FFFFFE DC800000_01 +FFFED156A62AB849 D79754AD_01 +0000000000FFFFFF 4B7FFFFF_00 +FFFFFFF83FEFFFFD D0F80201_01 +00015354EAE7C259 57A9AA75_01 +00000000007FFFFF 4AFFFFFE_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFF0F4DF3C75 D170B20D_01 +00000000003FFFFF 4A7FFFFC_00 +FFFA000000001FFF D8C00000_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000001FFFFF 49FFFFF8_00 +FFFFFFFFFF7FFE40 CB0001C0_00 +FFFFFFDB5433CB9B D212AF31_01 +00000000000FFFFF 497FFFF0_00 +FFFFFDFFDFFDFFFD D4000801_01 +FFFFFFFFFFDEAE1F CA054784_00 +000000000007FFFF 48FFFFE0_00 +FFFFFFFFF0080006 CD7F8000_01 +FFFFFFFE7735DEC7 CFC46511_01 +000000000003FFFF 487FFFC0_00 +00000001FBFFFFFF 4FFDFFFF_01 +000003757D8B12ED 545D5F62_01 +000000000001FFFF 47FFFF80_00 +FFFFFE07F7FFFFFF D3FC0401_01 +00000A654064E046 55265406_01 +000000000000FFFF 477FFF00_00 +08000000000017FF 5D000000_01 +FFFFFFFFFFFFFFE7 C1C80000_00 +0000000000007FFF 46FFFE00_00 +07FFFFFFFFFFFDF6 5CFFFFFF_01 +FFFFAD78B3D6C3B6 D6A50E99_01 +0000000000003FFF 467FFC00_00 +0000300004000000 56400010_00 +FFFFFFF70B77F34F D10F4881_01 +0000000000001FFF 45FFF800_00 +FFFFFF80006FFFFE D2FFFF21_01 +0000013EB4D67EC8 539F5A6B_01 +0000000000000FFF 457FF000_00 +BFFFDFFFFBFFFFFF DE800041_01 +0005CEAF34EA1DC7 58B9D5E6_01 +00000000000007FF 44FFE000_00 +00004800007FFFFD 56900000_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000000003FF 447FC000_00 +0000000200001000 50000004_00 +00000000000360D0 48583400_00 +00000000000001FF 43FF8000_00 +01003FFFFFFFFFFC 5B801FFF_01 +00C000708FF1BA51 5B400070_01 +00000000000000FF 437F0000_00 +F802000003FFFFFF DCFFC000_01 +0F9E07DCC0BDC061 5D79E07D_01 +000000000000007F 42FE0000_00 +03FF0000000000FF 5C7FC000_01 +FFFFFFE1B9B2A079 D1F2326B_01 +000000000000003F 427C0000_00 +FFF80000000080FF D9000000_01 +00000000001EB5B4 49F5ADA0_00 +000000000000001F 41F80000_00 +000000000077FBFE 4AEFF7FC_00 +00000000005AC607 4AB58C0E_00 +000000000000000F 41700000_00 +FFFFFFFEF80000FF CF840000_01 +000005C5B9D66984 54B8B73A_01 +0000000000000007 40E00000_00 +C001FFFFFFF00000 DE7FF801_01 +00001D06B372AA06 55E8359B_01 +0000000000000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_rne.tv b/wally-pipelined/testbench/fp/i64_f32_rne.tv new file mode 100644 index 000000000..e766e9aec --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f32_rne.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 5CFFFFC0_01 +0000000032CC8B7A 4E4B322E_01 +0000000000000000 00000000_00 +FFFFFFFFC0003FFE CE7FFF00_01 +032C857F319EDE38 5C4B2160_01 +0000000000000001 3F800000_00 +FFFFFBFFFFF8003E D4800001_01 +00394C79B6D3007B 5A6531E7_01 +0000000000000002 40000000_00 +FBFFFFF0000001FF DC800002_01 +0000000001AE458D 4BD722C6_01 +0000000000000004 40800000_00 +00040008000007FE 58800100_01 +F9EB456140D88764 DCC29754_01 +0000000000000008 41000000_00 +FFFFE400FFFFFFFE D5DFF800_01 +07DE834A248EDF36 5CFBD069_01 +0000000000000010 41800000_00 +00000003FF001FFF 507FC008_01 +FFFFFFFFFFE385E2 C9E3D0F0_00 +0000000000000020 42000000_00 +F0041FFFFFFFFFFF DD7FBE00_01 +000000059EB1FD45 50B3D640_01 +0000000000000040 42800000_00 +FFFFFFFFFFFCFFF9 C84001C0_00 +FFFFFFFFFFFEDDFE C7910100_00 +0000000000000080 43000000_00 +000000000003FF00 487FC000_00 +00000000C89FF56B 4F489FF5_01 +0000000000000100 43800000_00 +000FFFFF7FDFFFFF 597FFFF8_01 +1B5E4F0BE0DEBFF0 5DDAF278_01 +0000000000000200 44000000_00 +FFFDF803FFFFFFFF D801FF00_01 +FFFFFFFFFFF4766B C9389950_00 +0000000000000400 44800000_00 +0000080100000FFE 55001000_01 +000000000000000C 41400000_00 +0000000000000800 45000000_00 +0048000000100000 5A900000_01 +FFE662A109109D0A D9CCEAF8_01 +0000000000001000 45800000_00 +C000000037FFFFFE DE800000_01 +FFFFFFFFFFFFFFE4 C1E00000_00 +0000000000002000 46000000_00 +F801000000100000 DCFFE000_01 +FE114B79075F70EE DBF75A43_01 +0000000000004000 46800000_00 +100000000001003E 5D800000_01 +00000000000003AC 446B0000_00 +0000000000008000 47000000_00 +200000FFFFFFF800 5E000004_01 +00000044A3A3DBE5 52894748_01 +0000000000010000 47800000_00 +FFE0003EFFFFFFFF D9FFFE08_01 +FFFFFFFFFFFF1A91 C7656F00_00 +0000000000020000 48000000_00 +FFFFF7C3FFFFFFFD D503C000_01 +0000000000003309 464C2400_00 +0000000000040000 48800000_00 +000083FFF7FFFFFE 5703FFF8_01 +FFFFFFFFFFFFFF58 C3280000_00 +0000000000080000 49000000_00 +FFFFFFDE01FFFFFE D207F800_01 +0000000000002980 46260000_00 +0000000000100000 49800000_00 +00000000FFF07FFF 4F7FF080_01 +000000000000005D 42BA0000_00 +0000000000200000 4A000000_00 +000020FFDFFFFFFF 5603FF80_01 +FFFC8C23DA2CEAD8 D85CF709_01 +0000000000400000 4A800000_00 +E0000000003FFFDF DE000000_01 +FFFFFDE3C1DEC43C D4070F88_01 +0000000000800000 4B000000_00 +FFFF00000BFFFFFD D77FFFF4_01 +000000000030FFBE 4A43FEF8_00 +0000000001000000 4B800000_00 +FFFE000007FFEFFD D7FFFFFC_01 +FFFFFFFFEFDEED86 CD810894_01 +0000000002000000 4C000000_00 +F3FFFFFFFFBFFFFE DD400000_01 +000000001DA3FF45 4DED1FFA_01 +0000000004000000 4C800000_00 +FFFFFFFF00010007 CF7FFF00_01 +FFFFFFFE9B1BCB54 CFB2721A_01 +0000000008000000 4D000000_00 +00004000004001FE 56800001_01 +F27DD19DE6563714 DD5822E6_01 +0000000010000000 4D800000_00 +FFC00000004007FE DA800000_01 +000000000001A359 47D1AC80_00 +0000000020000000 4E000000_00 +0000000003C000FE 4C700040_01 +FFFFFFFFFE62EC20 CBCE89F0_00 +0000000040000000 4E800000_00 +000000003FFFFFFD 4E800000_01 +000000000000285F 46217C00_00 +0000000080000000 4F000000_00 +FFFFFFFFBFFFF00F CE800020_01 +FFFFF836F99DBAA8 D4F920CC_01 +0000000100000000 4F800000_00 +00000020003FFEFE 52000100_01 +0033466832042D47 5A4D19A1_01 +0000000200000000 50000000_00 +FFFFFFFFFFFFF887 C4EF2000_00 +00000000003829C8 4A60A720_00 +0000000400000000 50800000_00 +00000FFFFFFF7DFD 55800000_01 +0000000FB77C672B 517B77C6_01 +0000000800000000 51000000_00 +08003FFDFFFFFFFE 5D000400_01 +0000000000001B78 45DBC000_00 +0000001000000000 51800000_00 +FF7FFFFFFFEFDFFF DB000000_01 +0000000000000071 42E20000_00 +0000002000000000 52000000_00 +000013FFFFFFFDFF 55A00000_01 +FFFFFFFFFFFFFF86 C2F40000_00 +0000004000000000 52800000_00 +0800000000040800 5D000000_01 +FFF8A60D9E19F17E D8EB3E4C_01 +0000008000000000 53000000_00 +000077FFF0000000 56EFFFE0_00 +FFFFFFFFF7506DBA CD0AF924_01 +0000010000000000 53800000_00 +FFFFFFFFFFFEFBF7 C7820480_00 +FFFFFFFFFEA42AC9 CBADEA9C_01 +0000020000000000 54000000_00 +0000107FFFFFDFFD 55840000_01 +FFE7AA3F2BDACC89 D9C2AE07_01 +0000040000000000 54800000_00 +FFF8040000040000 D8FF8000_01 +FFFFFFFFFFFFFFFD C0400000_00 +0000080000000000 55000000_00 +FFFF80000800001F D6FFFFF0_01 +FFFDF681DECDADC9 D8025F88_01 +0000100000000000 55800000_00 +FFFFFEFFFFE0007F D3800010_01 +FFFFFFFFFFFFCFBE C6410800_00 +0000200000000000 56000000_00 +0000000901FFFFFD 51102000_01 +FEC01FECA24DE1B0 DB9FF00A_01 +0000400000000000 56800000_00 +F7FFFFFFDFFF7FFF DD000000_01 +F858A66761669936 DCF4EB33_01 +0000800000000000 57000000_00 +FFFEFF800000003E D7804000_01 +F716EA43FAC45C97 DD0E915C_01 +0001000000000000 57800000_00 +FFFFFFFFFFFFFFC6 C2680000_00 +0024D70EC7661FD8 5A135C3B_01 +0002000000000000 58000000_00 +C07FFFFFFFFFFFFE DE7E0000_01 +FFD956DBD0AEE817 DA1AA491_01 +0004000000000000 58800000_00 +020003EFFFFFFFFE 5C0000FC_01 +FFFFFFFFFFFF4300 C73D0000_00 +0008000000000000 59000000_00 +4000000004002000 5E800000_01 +C12EDF40F41F6021 DE7B4483_01 +0010000000000000 59800000_00 +FF9000000000001D DAE00000_01 +FFFFFFF83DE950F6 D0F842D6_01 +0020000000000000 5A000000_00 +800003FFFFFC0000 DEFFFFF8_01 +FE2B59CB3A604D69 DBEA531A_01 +0040000000000000 5A800000_00 +7FFFFFFDFFFFBFFF 5F000000_01 +000000A37C210862 53237C21_01 +0080000000000000 5B000000_00 +0002000002000002 58000001_01 +FFFFB65CD8617789 D693464F_01 +0100000000000000 5B800000_00 +00001BFFFFFFBFFE 55E00000_01 +FFFFFFFFFFFFF01D C57E3000_00 +0200000000000000 5C000000_00 +1000008000003FFF 5D800004_01 +000000000D098D19 4D5098D2_01 +0400000000000000 5C800000_00 +03FFFFFFFFFFF5FF 5C800000_01 +000006B3BD2C7BEF 54D677A6_01 +0800000000000000 5D000000_00 +00003FFFBFFFFFFE 567FFF00_01 +FFFF4E5ADDDAA4A8 D731A522_01 +1000000000000000 5D800000_00 +001FFFC000000FFD 59FFFE00_01 +FFFFFFFFFFFFFF21 C35F0000_00 +2000000000000000 5E000000_00 +0000000041DFFFFF 4E83C000_01 +FFFFFFFFFC648262 CC66DF68_01 +4000000000000000 5E800000_00 +C0001FFFFFFFFFFB DE7FFF80_01 +FFFFFF7353AC45D2 D30CAC54_01 +8000000000000000 DF000000_00 +FFFFFFFFFFE7EFFF C9C08008_00 +0000000000A1202D 4B21202D_00 +C000000000000000 DE800000_00 +FFFFFFFFFFFF5F7F C7208100_00 +000000000040CA70 4A8194E0_00 +E000000000000000 DE000000_00 +0000200201FFFFFE 56000808_01 +00000003B55D87D4 506D5762_01 +F000000000000000 DD800000_00 +FF80000DFFFFFFFF DAFFFFE4_01 +000000010510FAEF 4F82887D_01 +F800000000000000 DD000000_00 +0003FFF00000000F 587FFC00_01 +000000000000724A 46E49400_00 +FC00000000000000 DC800000_00 +FFFFFFDF80000002 D2020000_01 +0000000000000064 42C80000_00 +FE00000000000000 DC000000_00 +FEFFFFFFFFF800FE DB800000_01 +FFFFFFC2C6222702 D274E777_01 +FF00000000000000 DB800000_00 +0000000408000002 50810000_01 +000000E96DF1CB41 53696DF2_01 +FF80000000000000 DB000000_00 +007FFFFFFFFFF9FE 5B000000_01 +F727F174DEE7DC85 DD0D80E9_01 +FFC0000000000000 DA800000_00 +8000000003FFFEFE DF000000_01 +FFFFFFFFFFF0BD5B C9742A50_00 +FFE0000000000000 DA000000_00 +0BEFFFFFFFFFFFFF 5D3F0000_01 +000000000002790C 481E4300_00 +FFF0000000000000 D9800000_00 +FFFFFFFFFFEFFBFA C9802030_00 +000000169E75DF01 51B4F3AF_01 +FFF8000000000000 D9000000_00 +00000007FEFFDFFF 50FFDFFC_01 +000000000000000E 41600000_00 +FFFC000000000000 D8800000_00 +0003FFFE0007FFFE 587FFF80_01 +FFFFFFFFFFF28622 C9579DE0_00 +FFFE000000000000 D8000000_00 +FFFFFF7FFFFDF7FF D3000002_01 +00072F0EC496FE21 58E5E1D9_01 +FFFF000000000000 D7800000_00 +DFBFFFFFFFFFFFFE DE010000_01 +0000000000FC1FCA 4B7C1FCA_00 +FFFF800000000000 D7000000_00 +00000FFF800FFFFE 557FF801_01 +FFFF5194E4A9C2CE D72E6B1B_01 +FFFFC00000000000 D6800000_00 +00000002100007FD 50040002_01 +FFFFFFFFFFC2D8FE CA749C08_00 +FFFFE00000000000 D6000000_00 +000000000007FF6E 48FFEDC0_00 +000000000001766E 47BB3700_00 +FFFFF00000000000 D5800000_00 +0040000400000002 5A800008_01 +0000000000007841 46F08200_00 +FFFFF80000000000 D5000000_00 +3DFFFFFFFFFFFF7E 5E780000_01 +FFFFFFE549E17E30 D1D5B0F4_01 +FFFFFC0000000000 D4800000_00 +FFFFFFFFFFFFFEE1 C38F8000_00 +FFFFFFFFFFFFFFE7 C1C80000_00 +FFFFFE0000000000 D4000000_00 +000000000EFFFFDF 4D6FFFFE_01 +FFFFFFFFFFFFFF73 C30D0000_00 +FFFFFF0000000000 D3800000_00 +FD00000008000000 DC400000_01 +000000000001DBB1 47EDD880_00 +FFFFFF8000000000 D3000000_00 +FFFFFFFFFFF8007F C8FFF020_00 +FFFFFFFEFD10A515 CF8177AD_01 +FFFFFFC000000000 D2800000_00 +FFEFFFFFFFFFFFFE D9800000_01 +FAB02984F6283B6C DCA9FACF_01 +FFFFFFE000000000 D2000000_00 +FFFFFFBC000001FE D2880000_01 +FEB087C6B9FE7FE0 DBA7BC1D_01 +FFFFFFF000000000 D1800000_00 +FFF80001000007FE D8FFFFE0_01 +00F2762EA6837956 5B72762F_01 +FFFFFFF800000000 D1000000_00 +FFF7E0FFFFFFFFFE D901F000_01 +00002E1175484626 563845D5_01 +FFFFFFFC00000000 D0800000_00 +0000200020000FFE 56000080_01 +000000000000068F 44D1E000_00 +FFFFFFFE00000000 D0000000_00 +021FFFFFFFFBFFFF 5C080000_01 +FFFFFFFFFFFFFFF9 C0E00000_00 +FFFFFFFF00000000 CF800000_00 +FFFFFFD0000FFFFD D23FFFC0_01 +000000BDF6658B83 533DF666_01 +FFFFFFFF80000000 CF000000_00 +1000001FFDFFFFFF 5D800001_01 +0000000000003B5B 466D6C00_00 +FFFFFFFFC0000000 CE800000_00 +FFFFFFBFFE0FFFFF D28003E0_01 +FFFFFFFFFFFFFFF0 C1800000_00 +FFFFFFFFE0000000 CE000000_00 +FFFFFFFBF00007FF D081FFFF_01 +01E986274F48EAAD 5BF4C314_01 +FFFFFFFFF0000000 CD800000_00 +1FFFFFFDFFFFFF7F 5E000000_01 +FFFFFFFFFFFFCB5A C6529800_00 +FFFFFFFFF8000000 CD000000_00 +7FF000000000FFFF 5EFFE000_01 +00000003C2717FC3 50709C60_01 +FFFFFFFFFC000000 CC800000_00 +FFFFFFE00008001F D1FFFFC0_01 +FFFFFFFFFFEFABDA C982A130_00 +FFFFFFFFFE000000 CC000000_00 +0200000000000002 5C000000_01 +FFFFFFFFF8FDA53F CCE04B58_01 +FFFFFFFFFF000000 CB800000_00 +F6000003FFFFFFFE DD200000_01 +FFFFFFFFFFFFFFD0 C2400000_00 +FFFFFFFFFF800000 CB000000_00 +FFFFFFFFFFBFFF7E CA800104_00 +00000000EE0FEA62 4F6E0FEA_01 +FFFFFFFFFFC00000 CA800000_00 +0000007FFF9FFFFD 52FFFF40_01 +00000037F35EDC1D 525FCD7B_01 +FFFFFFFFFFE00000 CA000000_00 +FFFFFFF7FDFFFF7D D1002000_01 +00000000000001AD 43D68000_00 +FFFFFFFFFFF00000 C9800000_00 +FFFFFF0000100020 D37FFFF0_01 +27F167FBC7FC5F9A 5E1FC5A0_01 +FFFFFFFFFFF80000 C9000000_00 +003FFFFFFFFC0001 5A800000_01 +000E48F9F4EBD30E 59648F9F_01 +FFFFFFFFFFFC0000 C8800000_00 +DFFFFFFFFFFBFFFE DE000000_01 +FC91C23EE8C9424F DC5B8F70_01 +FFFFFFFFFFFE0000 C8000000_00 +F7DFFBFFFFFFFFFE DD020040_01 +000000002CAE080C 4E32B820_01 +FFFFFFFFFFFF0000 C7800000_00 +FFFFC00010000020 D67FFFC0_01 +04D921F917B20E40 5C9B243F_01 +FFFFFFFFFFFF8000 C7000000_00 +F8000FFFFFFFFFFD DCFFFE00_01 +FFF17C566BC7D811 D9683A99_01 +FFFFFFFFFFFFC000 C6800000_00 +00000000000000FE 437E0000_00 +FFF82AC14930D386 D8FAA7D7_01 +FFFFFFFFFFFFE000 C6000000_00 +00000000000003FC 447F0000_00 +000E62EC60E119FC 59662EC6_01 +FFFFFFFFFFFFF000 C5800000_00 +FFFFEFF7FF7FFFFE D5804004_01 +0E2B1ECF210EEDC5 5D62B1ED_01 +FFFFFFFFFFFFF800 C5000000_00 +00000000007FFF1F 4AFFFE3E_00 +FFFFFE534F5676F7 D3D65855_01 +FFFFFFFFFFFFFC00 C4800000_00 +0000001004FFFFFD 51802800_01 +0000035C939669F1 545724E6_01 +FFFFFFFFFFFFFE00 C4000000_00 +1FFFFFFFFFFFFDFD 5E000000_01 +FFFFFFFFFFFFFF91 C2DE0000_00 +FFFFFFFFFFFFFF00 C3800000_00 +01FFFFFFFBFFEFFE 5C000000_01 +000000000000016E 43B70000_00 +FFFFFFFFFFFFFF80 C3000000_00 +FFF7FFFFFFFFF7FD D9000000_01 +FFFFF8E2BCFAC553 D4E3A861_01 +FFFFFFFFFFFFFFC0 C2800000_00 +FFFFFBFFFFFE0FFE D4800000_01 +00000001A4E704BF 4FD27382_01 +FFFFFFFFFFFFFFE0 C2000000_00 +1400007FFFFFFFFD 5DA00004_01 +FFFFFFFC93B187B4 D05B139E_01 +FFFFFFFFFFFFFFF0 C1800000_00 +40000000007FFFFD 5E800000_01 +000000000067D468 4ACFA8D0_00 +FFFFFFFFFFFFFFF8 C1000000_00 +007FFEFFFFFBFFFE 5AFFFE00_01 +FFFFFFE26CEC79F8 D1EC989C_01 +FFFFFFFFFFFFFFFC C0800000_00 +00FFFFFF000000FF 5B7FFFFF_01 +FFFFFFFFE0D3983A CDF9633E_01 +FFFFFFFFFFFFFFFE C0000000_00 +00007FFFBFFF7FFE 56FFFF80_01 +FFFFFFFDF4A7088A D002D63E_01 +FFFFFFFFFFFFFFFF BF800000_00 +000008000000027E 55000000_01 +000000000000F4E8 4774E800_00 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFF83FFDF CAF80042_00 +00000E11407887B2 55611408_01 +FFFFFFFFFFFFFFFB C0A00000_00 +04000003FFFFFFF6 5C800000_01 +0000000000000513 44A26000_00 +FFFFFFFFFFFFFFF7 C1100000_00 +BFFC00000000003E DE800800_01 +00000008D7BBB75B 510D7BBB_01 +FFFFFFFFFFFFFFEF C1880000_00 +000FFFFBFFFC0000 597FFFC0_01 +FFFFFFFFFFCD5A23 CA4A9774_00 +FFFFFFFFFFFFFFDF C2040000_00 +FFBFDFFFBFFFFFFF DA804001_01 +000000000000007F 42FE0000_00 +FFFFFFFFFFFFFFBF C2820000_00 +00000007FF800003 50FFF000_01 +000000000002BB02 482EC080_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEE7FF C78C0080_00 +00264B2B9BAD0DA2 5A192CAE_01 +FFFFFFFFFFFFFEFF C3808000_00 +0000000000100803 49804018_00 +FF9B1DCB9F857D5E DAC9C469_01 +FFFFFFFFFFFFFDFF C4004000_00 +FFFFFFBFFFFFEFEE D2800000_01 +F6FD7542899C1C6F DD1028AC_01 +FFFFFFFFFFFFFBFF C4802000_00 +FF800000004001FF DB000000_01 +0000000002BE4932 4C2F924C_01 +FFFFFFFFFFFFF7FF C5001000_00 +00001004000FFFFE 55802000_01 +FFFFFF9DAA0123E0 D2C4ABFE_01 +FFFFFFFFFFFFEFFF C5800800_00 +00000001FDFFFDFE 4FFEFFFF_01 +FFFC1C8703B1DCB0 D878DE3F_01 +FFFFFFFFFFFFDFFF C6000400_00 +FE0FE00000000000 DBF81000_00 +0779ED944A4E2779 5CEF3DB3_01 +FFFFFFFFFFFFBFFF C6800200_00 +FBFFFE0400000000 DC800040_01 +0000010127E03666 538093F0_01 +FFFFFFFFFFFF7FFF C7000100_00 +FFFFF0200000FFFE D57E0000_01 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEFFFF C7800080_00 +FFEFFE0000080000 D9801000_01 +FFFFFFFFFD3354EA CC332AC6_01 +FFFFFFFFFFFDFFFF C8000040_00 +003FF0000003FFFE 5A7FC000_01 +0000006375B23F7B 52C6EB64_01 +FFFFFFFFFFFBFFFF C8800020_00 +000407FFFFFFFFF6 58810000_01 +0000000092117F38 4F12117F_01 +FFFFFFFFFFF7FFFF C9000010_00 +FFFFFFFFFFFF7FFF C7000100_00 +00000000000008BE 450BE000_00 +FFFFFFFFFFEFFFFF C9800008_00 +004000020FFFFFFF 5A800004_01 +FFFFB84C2D8BC9CB D68F67A5_01 +FFFFFFFFFFDFFFFF CA000004_00 +00FFFFFFFFFFFFFD 5B800000_01 +00000023C2C6F284 520F0B1C_01 +FFFFFFFFFFBFFFFF CA800002_00 +FFFDDFFFFFFFFFFD D8080000_01 +00000000746356C4 4EE8C6AE_01 +FFFFFFFFFF7FFFFF CB000001_00 +010000000000BFFF 5B800000_01 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFEFFFFFF CB800000_01 +FFFFBF7FFBFFFFFE D6810008_01 +00000006386CE889 50C70D9D_01 +FFFFFFFFFDFFFFFF CC000000_01 +F00000F7FFFFFFFF DD7FFFF1_01 +FFFDFC53090C46A4 D800EB3E_01 +FFFFFFFFFBFFFFFF CC800000_01 +0000000000800047 4B000047_00 +FFFFFFFFD693872E CE25B1E3_01 +FFFFFFFFF7FFFFFF CD000000_01 +000000007FBFFBFF 4EFF7FF8_01 +00000026A7845E35 521A9E11_01 +FFFFFFFFEFFFFFFF CD800000_01 +FFFFFFDFFFFFFBFD D2000000_01 +000000001433D14C 4DA19E8A_01 +FFFFFFFFDFFFFFFF CE000000_01 +0001FFFFFFE0000E 58000000_01 +F0F23E8068D3D84A DD70DC18_01 +FFFFFFFFBFFFFFFF CE800000_01 +F7FFBFFFFFFFBFFF DD000400_01 +FFFFBD29B7459087 D685AC91_01 +FFFFFFFF7FFFFFFF CF000000_01 +FFFFFFF8FFFFBFFF D0E00008_01 +FFFFFFFFFFEDDC06 C9911FD0_00 +FFFFFFFEFFFFFFFF CF800000_01 +FFFFFFF80001FFFF D0FFFFC0_01 +0000000000002FF9 463FE400_00 +FFFFFFFDFFFFFFFF D0000000_01 +004000040000FFFF 5A800008_01 +FFFFFFFFFFFFFFF1 C1700000_00 +FFFFFFFBFFFFFFFF D0800000_01 +C0000000007FFFFA DE800000_01 +FFFFFFFFFE053E2B CBFD60EA_01 +FFFFFFF7FFFFFFFF D1000000_01 +7FFE000007FFFFFF 5EFFFC00_01 +000000000000000D 41500000_00 +FFFFFFEFFFFFFFFF D1800000_01 +F80000000001007E DD000000_01 +FFFFED48424AD9D6 D595BDEE_01 +FFFFFFDFFFFFFFFF D2000000_01 +FFFFFE0001FEFFFF D3FFFF01_01 +000000000000013B 439D8000_00 +FFFFFFBFFFFFFFFF D2800000_01 +0007FBFFFFFDFFFE 58FF8000_01 +4A16BD4128090C83 5E942D7B_01 +FFFFFF7FFFFFFFFF D3000000_01 +00FFF7FFFF7FFFFE 5B7FF800_01 +0000000000000006 40C00000_00 +FFFFFEFFFFFFFFFF D3800000_01 +FBFFFFBFFFBFFFFF DC800008_01 +00000000000001BA 43DD0000_00 +FFFFFDFFFFFFFFFF D4000000_01 +0000000040000082 4E800001_01 +FF07A2BF5B689F89 DB785D41_01 +FFFFFBFFFFFFFFFF D4800000_01 +0000001FF8000008 51FFC000_01 +F87CAA7DE672DE8B DCF06AB0_01 +FFFFF7FFFFFFFFFF D5000000_01 +07FFF80000000002 5CFFFF00_01 +0000000010A1E5B8 4D850F2E_01 +FFFFEFFFFFFFFFFF D5800000_01 +F7FFFFE00007FFFF DD000002_01 +FFFFFFFFFFF6ADFC C9152040_00 +FFFFDFFFFFFFFFFF D6000000_01 +FFFFFF03FFFFFFC0 D37C0000_01 +EA579475948F0032 DDAD435C_01 +FFFFBFFFFFFFFFFF D6800000_01 +FC00000000003FF6 DC800000_01 +002E677AC313BF60 5A399DEB_01 +FFFF7FFFFFFFFFFF D7000000_01 +02000007FF7FFFFF 5C000002_01 +0000000E999639F1 51699964_01 +FFFEFFFFFFFFFFFF D7800000_01 +FFFF83FFFFFFFFBE D6F80000_01 +000000000001537D 47A9BE80_00 +FFFDFFFFFFFFFFFF D8000000_01 +EFFFFFC00000003D DD800002_01 +FFFFFFF21FEDFD35 D15E0120_01 +FFFBFFFFFFFFFFFF D8800000_01 +FFFFFFF0000007FE D1800000_01 +FFFFFFFFFFDE0839 CA07DF1C_00 +FFF7FFFFFFFFFFFF D9000000_01 +0000007FFFE000FF 52FFFFC0_01 +FFFFFFFF79F30F48 CF060CF1_01 +FFEFFFFFFFFFFFFF D9800000_01 +FFFFFC13FFFFFFFD D47B0000_01 +0000000000001B85 45DC2800_00 +FFDFFFFFFFFFFFFF DA000000_01 +000008000007FFFE 55000000_01 +12DB4409E5AE87E6 5D96DA20_01 +FFBFFFFFFFFFFFFF DA800000_01 +FFFFFFFFFFF7BFEE C9040120_00 +FFFFFFFFFFFFFFFD C0400000_00 +FF7FFFFFFFFFFFFF DB000000_01 +000000001040FFFE 4D820800_01 +00000909A09C13D3 55109A0A_01 +FEFFFFFFFFFFFFFF DB800000_01 +FFFFFF01FFFFFF7F D37E0000_01 +FFFFFF72E7D2575D D30D182E_01 +FDFFFFFFFFFFFFFF DC000000_01 +FFFFFFFFFFFEFFDB C7801280_00 +0000000000000017 41B80000_00 +FBFFFFFFFFFFFFFF DC800000_01 +100000001FFFFFF6 5D800000_01 +000000114B12EF51 518A5897_01 +F7FFFFFFFFFFFFFF DD000000_01 +0407FFFFFFFFFEFF 5C810000_01 +FFFFFF769F3A5C2C D30960C6_01 +EFFFFFFFFFFFFFFF DD800000_01 +FFFFFFFDF7FFFFFD D0020000_01 +FFFFFFFFFFFFFFF2 C1600000_00 +DFFFFFFFFFFFFFFF DE000000_01 +FFFFFFFFFE0007FF CBFFFC00_01 +000000000000001E 41F00000_00 +BFFFFFFFFFFFFFFF DE800000_01 +FFF800000009FFFF D9000000_01 +0000000000007AA4 46F54800_00 +7FFFFFFFFFFFFFFF 5F000000_01 +4080000000FFFFFF 5E810000_01 +000000000DE7601D 4D5E7602_01 +3FFFFFFFFFFFFFFF 5E800000_01 +FFCFFFFFFFBFFFFE DA400000_01 +FFFFFFFFFFFFFFCA C2580000_00 +1FFFFFFFFFFFFFFF 5E000000_01 +000080400000003F 57004000_01 +00000000001F75A5 49FBAD28_00 +0FFFFFFFFFFFFFFF 5D800000_01 +FFFFFFEFFFFFCFFE D1800002_01 +FFFFFEE775887420 D38C453C_01 +07FFFFFFFFFFFFFF 5D000000_01 +00000000000801FE 49001FE0_00 +0000000000213FF1 4A04FFC4_00 +03FFFFFFFFFFFFFF 5C800000_01 +07FEFFFFFFFFFFEE 5CFFE000_01 +0000000000000004 40800000_00 +01FFFFFFFFFFFFFF 5C000000_01 +0000000820000003 51020000_01 +FFFFFFF9AD105214 D0CA5DF6_01 +00FFFFFFFFFFFFFF 5B800000_01 +FFFFF00FFFFFFFBE D57F0000_01 +FFFFFFFFFFCC48E7 CA4EDC64_00 +007FFFFFFFFFFFFF 5B000000_01 +00000FFFEF7FFFFF 557FFEF8_01 +FFFFFFFFFF0BA6CB CB745935_00 +003FFFFFFFFFFFFF 5A800000_01 +FFFFFF7FBFFFFFBF D3004000_01 +FFFFFFFFFFF24425 C95BBDB0_00 +001FFFFFFFFFFFFF 5A000000_01 +200000001FFBFFFF 5E000000_01 +FFFFFF4E7115EC53 D3318EEA_01 +000FFFFFFFFFFFFF 59800000_01 +FFFFF803FFFFFFBF D4FF8000_01 +FFFFFC2E539ADCFE D4746B19_01 +0007FFFFFFFFFFFF 59000000_01 +FFFFFFFFFBFFFFFF CC800000_01 +00000055084732F3 52AA108E_01 +0003FFFFFFFFFFFF 58800000_01 +BFFF7FFFFFFFFE00 DE800100_01 +FFFFFFFFFFFF8543 C6F57A00_00 +0001FFFFFFFFFFFF 58000000_01 +0000001FFBFFE000 51FFDFFF_00 +FFFFFFFFFFFE491B C7DB7280_00 +0000FFFFFFFFFFFF 57800000_01 +FC00200000001FFE DC7FF800_01 +FFFFF16898822A24 D5697678_01 +00007FFFFFFFFFFF 57000000_01 +3FFF03FFFFFFFFFE 5E7FFC10_01 +FFFFFF8FFE18C7BF D2E003CE_01 +00003FFFFFFFFFFF 56800000_01 +FFFFFEFFFEFFFFFD D3800080_01 +00F03620C1266ED9 5B703621_01 +00001FFFFFFFFFFF 56000000_01 +BF7EFFFFFFFFFFFF DE810200_01 +FFFFFFFFFFFFFFD5 C22C0000_00 +00000FFFFFFFFFFF 55800000_01 +FFFBFFFFF803FFFE D8800001_01 +0000000000068684 48D0D080_00 +000007FFFFFFFFFF 55000000_01 +DFFFFFE00000001E DE000000_01 +FFFFFFFFFFFFECF5 C5985800_00 +000003FFFFFFFFFF 54800000_01 +FFFF00400000FFFF D77FC000_01 +0000000000000002 40000000_00 +000001FFFFFFFFFF 54000000_01 +FBFFFFFFFFFFBDFE DC800000_01 +0000000000000BC9 453C9000_00 +000000FFFFFFFFFF 53800000_01 +807FFFFFFFFFDFFE DEFF0000_01 +FFC274E35A70CD76 DA762C73_01 +0000007FFFFFFFFF 53000000_01 +0FFFFFFFFEFFFFFD 5D800000_01 +FFFFFFFF00E73AFC CF7F18C5_01 +0000003FFFFFFFFF 52800000_01 +FFC000000001000E DA800000_01 +FFFFFFFFFFFE15E9 C7F50B80_00 +0000001FFFFFFFFF 52000000_01 +0001FFFFFFFFF3FD 58000000_01 +0000000000000033 424C0000_00 +0000000FFFFFFFFF 51800000_01 +000000001FFFBFFF 4DFFFE00_01 +FFFFFFEE6B141E1B D18CA75F_01 +00000007FFFFFFFF 51000000_01 +FFFFFFFFF60007FF CD1FFF80_01 +00000001AB310BA6 4FD59886_01 +00000003FFFFFFFF 50800000_01 +0003FFFFB7FFFFFF 587FFFEE_01 +FFFFFFFFFFFFF195 C566B000_00 +00000001FFFFFFFF 50000000_01 +FFFFFFFF8000000B CF000000_01 +00000019BA8D5559 51CDD46B_01 +00000000FFFFFFFF 4F800000_01 +FBFEFFFFFFFFFFF9 DC802000_01 +FFFFFFB6F062822D D2921F3B_01 +000000007FFFFFFF 4F000000_01 +0001000000000082 57800000_01 +01CEAD9E2FB104A4 5BE756CF_01 +000000003FFFFFFF 4E800000_01 +000003FFFFFFFF7C 54800000_01 +FFFFFFFFFD681E78 CC25F862_00 +000000001FFFFFFF 4E000000_01 +00002000400001FF 56000100_01 +0000000000000018 41C00000_00 +000000000FFFFFFF 4D800000_01 +3FFF80000000003E 5E7FFE00_01 +FFFFFFFFFFFFFF95 C2D60000_00 +0000000007FFFFFF 4D000000_01 +010000BFFFFFFFFF 5B800060_01 +0000001697087B19 51B4B844_01 +0000000003FFFFFF 4C800000_01 +FBFFFFFFFFEEFFFD DC800000_01 +0000000E64BDFC55 51664BE0_01 +0000000001FFFFFF 4C000000_01 +FC00000001FFFFFE DC800000_01 +FFFED156A62AB849 D79754AD_01 +0000000000FFFFFF 4B7FFFFF_00 +FFFFFFF83FEFFFFD D0F80200_01 +00015354EAE7C259 57A9AA75_01 +00000000007FFFFF 4AFFFFFE_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFF0F4DF3C75 D170B20C_01 +00000000003FFFFF 4A7FFFFC_00 +FFFA000000001FFF D8C00000_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000001FFFFF 49FFFFF8_00 +FFFFFFFFFF7FFE40 CB0001C0_00 +FFFFFFDB5433CB9B D212AF31_01 +00000000000FFFFF 497FFFF0_00 +FFFFFDFFDFFDFFFD D4000801_01 +FFFFFFFFFFDEAE1F CA054784_00 +000000000007FFFF 48FFFFE0_00 +FFFFFFFFF0080006 CD7F8000_01 +FFFFFFFE7735DEC7 CFC46511_01 +000000000003FFFF 487FFFC0_00 +00000001FBFFFFFF 4FFE0000_01 +000003757D8B12ED 545D5F63_01 +000000000001FFFF 47FFFF80_00 +FFFFFE07F7FFFFFF D3FC0400_01 +00000A654064E046 55265406_01 +000000000000FFFF 477FFF00_00 +08000000000017FF 5D000000_01 +FFFFFFFFFFFFFFE7 C1C80000_00 +0000000000007FFF 46FFFE00_00 +07FFFFFFFFFFFDF6 5D000000_01 +FFFFAD78B3D6C3B6 D6A50E98_01 +0000000000003FFF 467FFC00_00 +0000300004000000 56400010_00 +FFFFFFF70B77F34F D10F4881_01 +0000000000001FFF 45FFF800_00 +FFFFFF80006FFFFE D2FFFF20_01 +0000013EB4D67EC8 539F5A6B_01 +0000000000000FFF 457FF000_00 +BFFFDFFFFBFFFFFF DE800040_01 +0005CEAF34EA1DC7 58B9D5E7_01 +00000000000007FF 44FFE000_00 +00004800007FFFFD 56900001_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000000003FF 447FC000_00 +0000000200001000 50000004_00 +00000000000360D0 48583400_00 +00000000000001FF 43FF8000_00 +01003FFFFFFFFFFC 5B802000_01 +00C000708FF1BA51 5B400071_01 +00000000000000FF 437F0000_00 +F802000003FFFFFF DCFFC000_01 +0F9E07DCC0BDC061 5D79E07E_01 +000000000000007F 42FE0000_00 +03FF0000000000FF 5C7FC000_01 +FFFFFFE1B9B2A079 D1F2326B_01 +000000000000003F 427C0000_00 +FFF80000000080FF D9000000_01 +00000000001EB5B4 49F5ADA0_00 +000000000000001F 41F80000_00 +000000000077FBFE 4AEFF7FC_00 +00000000005AC607 4AB58C0E_00 +000000000000000F 41700000_00 +FFFFFFFEF80000FF CF840000_01 +000005C5B9D66984 54B8B73B_01 +0000000000000007 40E00000_00 +C001FFFFFFF00000 DE7FF800_01 +00001D06B372AA06 55E8359C_01 +0000000000000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_ru.tv b/wally-pipelined/testbench/fp/i64_f32_ru.tv new file mode 100644 index 000000000..b8828358f --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f32_ru.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 5CFFFFC0_01 +0000000032CC8B7A 4E4B322E_01 +0000000000000000 00000000_00 +FFFFFFFFC0003FFE CE7FFF00_01 +032C857F319EDE38 5C4B2160_01 +0000000000000001 3F800000_00 +FFFFFBFFFFF8003E D4800000_01 +00394C79B6D3007B 5A6531E7_01 +0000000000000002 40000000_00 +FBFFFFF0000001FF DC800001_01 +0000000001AE458D 4BD722C7_01 +0000000000000004 40800000_00 +00040008000007FE 58800101_01 +F9EB456140D88764 DCC29753_01 +0000000000000008 41000000_00 +FFFFE400FFFFFFFE D5DFF800_01 +07DE834A248EDF36 5CFBD06A_01 +0000000000000010 41800000_00 +00000003FF001FFF 507FC008_01 +FFFFFFFFFFE385E2 C9E3D0F0_00 +0000000000000020 42000000_00 +F0041FFFFFFFFFFF DD7FBE00_01 +000000059EB1FD45 50B3D640_01 +0000000000000040 42800000_00 +FFFFFFFFFFFCFFF9 C84001C0_00 +FFFFFFFFFFFEDDFE C7910100_00 +0000000000000080 43000000_00 +000000000003FF00 487FC000_00 +00000000C89FF56B 4F489FF6_01 +0000000000000100 43800000_00 +000FFFFF7FDFFFFF 597FFFF8_01 +1B5E4F0BE0DEBFF0 5DDAF279_01 +0000000000000200 44000000_00 +FFFDF803FFFFFFFF D801FF00_01 +FFFFFFFFFFF4766B C9389950_00 +0000000000000400 44800000_00 +0000080100000FFE 55001001_01 +000000000000000C 41400000_00 +0000000000000800 45000000_00 +0048000000100000 5A900001_01 +FFE662A109109D0A D9CCEAF7_01 +0000000000001000 45800000_00 +C000000037FFFFFE DE7FFFFF_01 +FFFFFFFFFFFFFFE4 C1E00000_00 +0000000000002000 46000000_00 +F801000000100000 DCFFDFFF_01 +FE114B79075F70EE DBF75A43_01 +0000000000004000 46800000_00 +100000000001003E 5D800001_01 +00000000000003AC 446B0000_00 +0000000000008000 47000000_00 +200000FFFFFFF800 5E000004_01 +00000044A3A3DBE5 52894748_01 +0000000000010000 47800000_00 +FFE0003EFFFFFFFF D9FFFE08_01 +FFFFFFFFFFFF1A91 C7656F00_00 +0000000000020000 48000000_00 +FFFFF7C3FFFFFFFD D503C000_01 +0000000000003309 464C2400_00 +0000000000040000 48800000_00 +000083FFF7FFFFFE 5703FFF8_01 +FFFFFFFFFFFFFF58 C3280000_00 +0000000000080000 49000000_00 +FFFFFFDE01FFFFFE D207F800_01 +0000000000002980 46260000_00 +0000000000100000 49800000_00 +00000000FFF07FFF 4F7FF080_01 +000000000000005D 42BA0000_00 +0000000000200000 4A000000_00 +000020FFDFFFFFFF 5603FF80_01 +FFFC8C23DA2CEAD8 D85CF709_01 +0000000000400000 4A800000_00 +E0000000003FFFDF DDFFFFFF_01 +FFFFFDE3C1DEC43C D4070F88_01 +0000000000800000 4B000000_00 +FFFF00000BFFFFFD D77FFFF4_01 +000000000030FFBE 4A43FEF8_00 +0000000001000000 4B800000_00 +FFFE000007FFEFFD D7FFFFFC_01 +FFFFFFFFEFDEED86 CD810893_01 +0000000002000000 4C000000_00 +F3FFFFFFFFBFFFFE DD400000_01 +000000001DA3FF45 4DED1FFB_01 +0000000004000000 4C800000_00 +FFFFFFFF00010007 CF7FFEFF_01 +FFFFFFFE9B1BCB54 CFB2721A_01 +0000000008000000 4D000000_00 +00004000004001FE 56800001_01 +F27DD19DE6563714 DD5822E6_01 +0000000010000000 4D800000_00 +FFC00000004007FE DA7FFFFF_01 +000000000001A359 47D1AC80_00 +0000000020000000 4E000000_00 +0000000003C000FE 4C700040_01 +FFFFFFFFFE62EC20 CBCE89F0_00 +0000000040000000 4E800000_00 +000000003FFFFFFD 4E800000_01 +000000000000285F 46217C00_00 +0000000080000000 4F000000_00 +FFFFFFFFBFFFF00F CE80001F_01 +FFFFF836F99DBAA8 D4F920CC_01 +0000000100000000 4F800000_00 +00000020003FFEFE 52000100_01 +0033466832042D47 5A4D19A1_01 +0000000200000000 50000000_00 +FFFFFFFFFFFFF887 C4EF2000_00 +00000000003829C8 4A60A720_00 +0000000400000000 50800000_00 +00000FFFFFFF7DFD 55800000_01 +0000000FB77C672B 517B77C7_01 +0000000800000000 51000000_00 +08003FFDFFFFFFFE 5D000400_01 +0000000000001B78 45DBC000_00 +0000001000000000 51800000_00 +FF7FFFFFFFEFDFFF DB000000_01 +0000000000000071 42E20000_00 +0000002000000000 52000000_00 +000013FFFFFFFDFF 55A00000_01 +FFFFFFFFFFFFFF86 C2F40000_00 +0000004000000000 52800000_00 +0800000000040800 5D000001_01 +FFF8A60D9E19F17E D8EB3E4C_01 +0000008000000000 53000000_00 +000077FFF0000000 56EFFFE0_00 +FFFFFFFFF7506DBA CD0AF924_01 +0000010000000000 53800000_00 +FFFFFFFFFFFEFBF7 C7820480_00 +FFFFFFFFFEA42AC9 CBADEA9B_01 +0000020000000000 54000000_00 +0000107FFFFFDFFD 55840000_01 +FFE7AA3F2BDACC89 D9C2AE06_01 +0000040000000000 54800000_00 +FFF8040000040000 D8FF7FFF_01 +FFFFFFFFFFFFFFFD C0400000_00 +0000080000000000 55000000_00 +FFFF80000800001F D6FFFFEF_01 +FFFDF681DECDADC9 D8025F88_01 +0000100000000000 55800000_00 +FFFFFEFFFFE0007F D380000F_01 +FFFFFFFFFFFFCFBE C6410800_00 +0000200000000000 56000000_00 +0000000901FFFFFD 51102000_01 +FEC01FECA24DE1B0 DB9FF009_01 +0000400000000000 56800000_00 +F7FFFFFFDFFF7FFF DD000000_01 +F858A66761669936 DCF4EB33_01 +0000800000000000 57000000_00 +FFFEFF800000003E D7803FFF_01 +F716EA43FAC45C97 DD0E915B_01 +0001000000000000 57800000_00 +FFFFFFFFFFFFFFC6 C2680000_00 +0024D70EC7661FD8 5A135C3C_01 +0002000000000000 58000000_00 +C07FFFFFFFFFFFFE DE7E0000_01 +FFD956DBD0AEE817 DA1AA490_01 +0004000000000000 58800000_00 +020003EFFFFFFFFE 5C0000FC_01 +FFFFFFFFFFFF4300 C73D0000_00 +0008000000000000 59000000_00 +4000000004002000 5E800001_01 +C12EDF40F41F6021 DE7B4482_01 +0010000000000000 59800000_00 +FF9000000000001D DADFFFFF_01 +FFFFFFF83DE950F6 D0F842D5_01 +0020000000000000 5A000000_00 +800003FFFFFC0000 DEFFFFF8_01 +FE2B59CB3A604D69 DBEA531A_01 +0040000000000000 5A800000_00 +7FFFFFFDFFFFBFFF 5F000000_01 +000000A37C210862 53237C22_01 +0080000000000000 5B000000_00 +0002000002000002 58000001_01 +FFFFB65CD8617789 D693464F_01 +0100000000000000 5B800000_00 +00001BFFFFFFBFFE 55E00000_01 +FFFFFFFFFFFFF01D C57E3000_00 +0200000000000000 5C000000_00 +1000008000003FFF 5D800005_01 +000000000D098D19 4D5098D2_01 +0400000000000000 5C800000_00 +03FFFFFFFFFFF5FF 5C800000_01 +000006B3BD2C7BEF 54D677A6_01 +0800000000000000 5D000000_00 +00003FFFBFFFFFFE 567FFF00_01 +FFFF4E5ADDDAA4A8 D731A522_01 +1000000000000000 5D800000_00 +001FFFC000000FFD 59FFFE01_01 +FFFFFFFFFFFFFF21 C35F0000_00 +2000000000000000 5E000000_00 +0000000041DFFFFF 4E83C000_01 +FFFFFFFFFC648262 CC66DF67_01 +4000000000000000 5E800000_00 +C0001FFFFFFFFFFB DE7FFF80_01 +FFFFFF7353AC45D2 D30CAC53_01 +8000000000000000 DF000000_00 +FFFFFFFFFFE7EFFF C9C08008_00 +0000000000A1202D 4B21202D_00 +C000000000000000 DE800000_00 +FFFFFFFFFFFF5F7F C7208100_00 +000000000040CA70 4A8194E0_00 +E000000000000000 DE000000_00 +0000200201FFFFFE 56000808_01 +00000003B55D87D4 506D5762_01 +F000000000000000 DD800000_00 +FF80000DFFFFFFFF DAFFFFE4_01 +000000010510FAEF 4F82887E_01 +F800000000000000 DD000000_00 +0003FFF00000000F 587FFC01_01 +000000000000724A 46E49400_00 +FC00000000000000 DC800000_00 +FFFFFFDF80000002 D201FFFF_01 +0000000000000064 42C80000_00 +FE00000000000000 DC000000_00 +FEFFFFFFFFF800FE DB800000_01 +FFFFFFC2C6222702 D274E777_01 +FF00000000000000 DB800000_00 +0000000408000002 50810001_01 +000000E96DF1CB41 53696DF2_01 +FF80000000000000 DB000000_00 +007FFFFFFFFFF9FE 5B000000_01 +F727F174DEE7DC85 DD0D80E8_01 +FFC0000000000000 DA800000_00 +8000000003FFFEFE DEFFFFFF_01 +FFFFFFFFFFF0BD5B C9742A50_00 +FFE0000000000000 DA000000_00 +0BEFFFFFFFFFFFFF 5D3F0000_01 +000000000002790C 481E4300_00 +FFF0000000000000 D9800000_00 +FFFFFFFFFFEFFBFA C9802030_00 +000000169E75DF01 51B4F3AF_01 +FFF8000000000000 D9000000_00 +00000007FEFFDFFF 50FFDFFC_01 +000000000000000E 41600000_00 +FFFC000000000000 D8800000_00 +0003FFFE0007FFFE 587FFF81_01 +FFFFFFFFFFF28622 C9579DE0_00 +FFFE000000000000 D8000000_00 +FFFFFF7FFFFDF7FF D3000002_01 +00072F0EC496FE21 58E5E1D9_01 +FFFF000000000000 D7800000_00 +DFBFFFFFFFFFFFFE DE010000_01 +0000000000FC1FCA 4B7C1FCA_00 +FFFF800000000000 D7000000_00 +00000FFF800FFFFE 557FF801_01 +FFFF5194E4A9C2CE D72E6B1B_01 +FFFFC00000000000 D6800000_00 +00000002100007FD 50040002_01 +FFFFFFFFFFC2D8FE CA749C08_00 +FFFFE00000000000 D6000000_00 +000000000007FF6E 48FFEDC0_00 +000000000001766E 47BB3700_00 +FFFFF00000000000 D5800000_00 +0040000400000002 5A800009_01 +0000000000007841 46F08200_00 +FFFFF80000000000 D5000000_00 +3DFFFFFFFFFFFF7E 5E780000_01 +FFFFFFE549E17E30 D1D5B0F4_01 +FFFFFC0000000000 D4800000_00 +FFFFFFFFFFFFFEE1 C38F8000_00 +FFFFFFFFFFFFFFE7 C1C80000_00 +FFFFFE0000000000 D4000000_00 +000000000EFFFFDF 4D6FFFFE_01 +FFFFFFFFFFFFFF73 C30D0000_00 +FFFFFF0000000000 D3800000_00 +FD00000008000000 DC3FFFFF_01 +000000000001DBB1 47EDD880_00 +FFFFFF8000000000 D3000000_00 +FFFFFFFFFFF8007F C8FFF020_00 +FFFFFFFEFD10A515 CF8177AD_01 +FFFFFFC000000000 D2800000_00 +FFEFFFFFFFFFFFFE D9800000_01 +FAB02984F6283B6C DCA9FACF_01 +FFFFFFE000000000 D2000000_00 +FFFFFFBC000001FE D287FFFF_01 +FEB087C6B9FE7FE0 DBA7BC1C_01 +FFFFFFF000000000 D1800000_00 +FFF80001000007FE D8FFFFDF_01 +00F2762EA6837956 5B72762F_01 +FFFFFFF800000000 D1000000_00 +FFF7E0FFFFFFFFFE D901F000_01 +00002E1175484626 563845D6_01 +FFFFFFFC00000000 D0800000_00 +0000200020000FFE 56000081_01 +000000000000068F 44D1E000_00 +FFFFFFFE00000000 D0000000_00 +021FFFFFFFFBFFFF 5C080000_01 +FFFFFFFFFFFFFFF9 C0E00000_00 +FFFFFFFF00000000 CF800000_00 +FFFFFFD0000FFFFD D23FFFC0_01 +000000BDF6658B83 533DF666_01 +FFFFFFFF80000000 CF000000_00 +1000001FFDFFFFFF 5D800001_01 +0000000000003B5B 466D6C00_00 +FFFFFFFFC0000000 CE800000_00 +FFFFFFBFFE0FFFFF D28003E0_01 +FFFFFFFFFFFFFFF0 C1800000_00 +FFFFFFFFE0000000 CE000000_00 +FFFFFFFBF00007FF D081FFFF_01 +01E986274F48EAAD 5BF4C314_01 +FFFFFFFFF0000000 CD800000_00 +1FFFFFFDFFFFFF7F 5E000000_01 +FFFFFFFFFFFFCB5A C6529800_00 +FFFFFFFFF8000000 CD000000_00 +7FF000000000FFFF 5EFFE001_01 +00000003C2717FC3 50709C60_01 +FFFFFFFFFC000000 CC800000_00 +FFFFFFE00008001F D1FFFFBF_01 +FFFFFFFFFFEFABDA C982A130_00 +FFFFFFFFFE000000 CC000000_00 +0200000000000002 5C000001_01 +FFFFFFFFF8FDA53F CCE04B58_01 +FFFFFFFFFF000000 CB800000_00 +F6000003FFFFFFFE DD1FFFFF_01 +FFFFFFFFFFFFFFD0 C2400000_00 +FFFFFFFFFF800000 CB000000_00 +FFFFFFFFFFBFFF7E CA800104_00 +00000000EE0FEA62 4F6E0FEB_01 +FFFFFFFFFFC00000 CA800000_00 +0000007FFF9FFFFD 52FFFF40_01 +00000037F35EDC1D 525FCD7C_01 +FFFFFFFFFFE00000 CA000000_00 +FFFFFFF7FDFFFF7D D1002000_01 +00000000000001AD 43D68000_00 +FFFFFFFFFFF00000 C9800000_00 +FFFFFF0000100020 D37FFFEF_01 +27F167FBC7FC5F9A 5E1FC5A0_01 +FFFFFFFFFFF80000 C9000000_00 +003FFFFFFFFC0001 5A800000_01 +000E48F9F4EBD30E 59648FA0_01 +FFFFFFFFFFFC0000 C8800000_00 +DFFFFFFFFFFBFFFE DE000000_01 +FC91C23EE8C9424F DC5B8F70_01 +FFFFFFFFFFFE0000 C8000000_00 +F7DFFBFFFFFFFFFE DD020040_01 +000000002CAE080C 4E32B821_01 +FFFFFFFFFFFF0000 C7800000_00 +FFFFC00010000020 D67FFFBF_01 +04D921F917B20E40 5C9B2440_01 +FFFFFFFFFFFF8000 C7000000_00 +F8000FFFFFFFFFFD DCFFFE00_01 +FFF17C566BC7D811 D9683A99_01 +FFFFFFFFFFFFC000 C6800000_00 +00000000000000FE 437E0000_00 +FFF82AC14930D386 D8FAA7D6_01 +FFFFFFFFFFFFE000 C6000000_00 +00000000000003FC 447F0000_00 +000E62EC60E119FC 59662EC7_01 +FFFFFFFFFFFFF000 C5800000_00 +FFFFEFF7FF7FFFFE D5804004_01 +0E2B1ECF210EEDC5 5D62B1ED_01 +FFFFFFFFFFFFF800 C5000000_00 +00000000007FFF1F 4AFFFE3E_00 +FFFFFE534F5676F7 D3D65854_01 +FFFFFFFFFFFFFC00 C4800000_00 +0000001004FFFFFD 51802800_01 +0000035C939669F1 545724E6_01 +FFFFFFFFFFFFFE00 C4000000_00 +1FFFFFFFFFFFFDFD 5E000000_01 +FFFFFFFFFFFFFF91 C2DE0000_00 +FFFFFFFFFFFFFF00 C3800000_00 +01FFFFFFFBFFEFFE 5C000000_01 +000000000000016E 43B70000_00 +FFFFFFFFFFFFFF80 C3000000_00 +FFF7FFFFFFFFF7FD D9000000_01 +FFFFF8E2BCFAC553 D4E3A860_01 +FFFFFFFFFFFFFFC0 C2800000_00 +FFFFFBFFFFFE0FFE D4800000_01 +00000001A4E704BF 4FD27383_01 +FFFFFFFFFFFFFFE0 C2000000_00 +1400007FFFFFFFFD 5DA00004_01 +FFFFFFFC93B187B4 D05B139E_01 +FFFFFFFFFFFFFFF0 C1800000_00 +40000000007FFFFD 5E800001_01 +000000000067D468 4ACFA8D0_00 +FFFFFFFFFFFFFFF8 C1000000_00 +007FFEFFFFFBFFFE 5AFFFE00_01 +FFFFFFE26CEC79F8 D1EC989C_01 +FFFFFFFFFFFFFFFC C0800000_00 +00FFFFFF000000FF 5B800000_01 +FFFFFFFFE0D3983A CDF9633E_01 +FFFFFFFFFFFFFFFE C0000000_00 +00007FFFBFFF7FFE 56FFFF80_01 +FFFFFFFDF4A7088A D002D63D_01 +FFFFFFFFFFFFFFFF BF800000_00 +000008000000027E 55000001_01 +000000000000F4E8 4774E800_00 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFF83FFDF CAF80042_00 +00000E11407887B2 55611408_01 +FFFFFFFFFFFFFFFB C0A00000_00 +04000003FFFFFFF6 5C800001_01 +0000000000000513 44A26000_00 +FFFFFFFFFFFFFFF7 C1100000_00 +BFFC00000000003E DE8007FF_01 +00000008D7BBB75B 510D7BBC_01 +FFFFFFFFFFFFFFEF C1880000_00 +000FFFFBFFFC0000 597FFFC0_01 +FFFFFFFFFFCD5A23 CA4A9774_00 +FFFFFFFFFFFFFFDF C2040000_00 +FFBFDFFFBFFFFFFF DA804000_01 +000000000000007F 42FE0000_00 +FFFFFFFFFFFFFFBF C2820000_00 +00000007FF800003 50FFF001_01 +000000000002BB02 482EC080_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEE7FF C78C0080_00 +00264B2B9BAD0DA2 5A192CAF_01 +FFFFFFFFFFFFFEFF C3808000_00 +0000000000100803 49804018_00 +FF9B1DCB9F857D5E DAC9C468_01 +FFFFFFFFFFFFFDFF C4004000_00 +FFFFFFBFFFFFEFEE D2800000_01 +F6FD7542899C1C6F DD1028AB_01 +FFFFFFFFFFFFFBFF C4802000_00 +FF800000004001FF DAFFFFFF_01 +0000000002BE4932 4C2F924D_01 +FFFFFFFFFFFFF7FF C5001000_00 +00001004000FFFFE 55802001_01 +FFFFFF9DAA0123E0 D2C4ABFD_01 +FFFFFFFFFFFFEFFF C5800800_00 +00000001FDFFFDFE 4FFEFFFF_01 +FFFC1C8703B1DCB0 D878DE3F_01 +FFFFFFFFFFFFDFFF C6000400_00 +FE0FE00000000000 DBF81000_00 +0779ED944A4E2779 5CEF3DB3_01 +FFFFFFFFFFFFBFFF C6800200_00 +FBFFFE0400000000 DC80003F_01 +0000010127E03666 538093F1_01 +FFFFFFFFFFFF7FFF C7000100_00 +FFFFF0200000FFFE D57DFFFF_01 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEFFFF C7800080_00 +FFEFFE0000080000 D9800FFF_01 +FFFFFFFFFD3354EA CC332AC5_01 +FFFFFFFFFFFDFFFF C8000040_00 +003FF0000003FFFE 5A7FC001_01 +0000006375B23F7B 52C6EB65_01 +FFFFFFFFFFFBFFFF C8800020_00 +000407FFFFFFFFF6 58810000_01 +0000000092117F38 4F121180_01 +FFFFFFFFFFF7FFFF C9000010_00 +FFFFFFFFFFFF7FFF C7000100_00 +00000000000008BE 450BE000_00 +FFFFFFFFFFEFFFFF C9800008_00 +004000020FFFFFFF 5A800005_01 +FFFFB84C2D8BC9CB D68F67A4_01 +FFFFFFFFFFDFFFFF CA000004_00 +00FFFFFFFFFFFFFD 5B800000_01 +00000023C2C6F284 520F0B1C_01 +FFFFFFFFFFBFFFFF CA800002_00 +FFFDDFFFFFFFFFFD D8080000_01 +00000000746356C4 4EE8C6AE_01 +FFFFFFFFFF7FFFFF CB000001_00 +010000000000BFFF 5B800001_01 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFEFFFFFF CB800000_01 +FFFFBF7FFBFFFFFE D6810008_01 +00000006386CE889 50C70D9E_01 +FFFFFFFFFDFFFFFF CC000000_01 +F00000F7FFFFFFFF DD7FFFF0_01 +FFFDFC53090C46A4 D800EB3D_01 +FFFFFFFFFBFFFFFF CC800000_01 +0000000000800047 4B000047_00 +FFFFFFFFD693872E CE25B1E3_01 +FFFFFFFFF7FFFFFF CD000000_01 +000000007FBFFBFF 4EFF7FF8_01 +00000026A7845E35 521A9E12_01 +FFFFFFFFEFFFFFFF CD800000_01 +FFFFFFDFFFFFFBFD D2000000_01 +000000001433D14C 4DA19E8B_01 +FFFFFFFFDFFFFFFF CE000000_01 +0001FFFFFFE0000E 58000000_01 +F0F23E8068D3D84A DD70DC17_01 +FFFFFFFFBFFFFFFF CE800000_01 +F7FFBFFFFFFFBFFF DD000400_01 +FFFFBD29B7459087 D685AC91_01 +FFFFFFFF7FFFFFFF CF000000_01 +FFFFFFF8FFFFBFFF D0E00008_01 +FFFFFFFFFFEDDC06 C9911FD0_00 +FFFFFFFEFFFFFFFF CF800000_01 +FFFFFFF80001FFFF D0FFFFC0_01 +0000000000002FF9 463FE400_00 +FFFFFFFDFFFFFFFF D0000000_01 +004000040000FFFF 5A800009_01 +FFFFFFFFFFFFFFF1 C1700000_00 +FFFFFFFBFFFFFFFF D0800000_01 +C0000000007FFFFA DE7FFFFF_01 +FFFFFFFFFE053E2B CBFD60EA_01 +FFFFFFF7FFFFFFFF D1000000_01 +7FFE000007FFFFFF 5EFFFC01_01 +000000000000000D 41500000_00 +FFFFFFEFFFFFFFFF D1800000_01 +F80000000001007E DCFFFFFF_01 +FFFFED48424AD9D6 D595BDED_01 +FFFFFFDFFFFFFFFF D2000000_01 +FFFFFE0001FEFFFF D3FFFF00_01 +000000000000013B 439D8000_00 +FFFFFFBFFFFFFFFF D2800000_01 +0007FBFFFFFDFFFE 58FF8000_01 +4A16BD4128090C83 5E942D7B_01 +FFFFFF7FFFFFFFFF D3000000_01 +00FFF7FFFF7FFFFE 5B7FF800_01 +0000000000000006 40C00000_00 +FFFFFEFFFFFFFFFF D3800000_01 +FBFFFFBFFFBFFFFF DC800008_01 +00000000000001BA 43DD0000_00 +FFFFFDFFFFFFFFFF D4000000_01 +0000000040000082 4E800002_01 +FF07A2BF5B689F89 DB785D40_01 +FFFFFBFFFFFFFFFF D4800000_01 +0000001FF8000008 51FFC001_01 +F87CAA7DE672DE8B DCF06AB0_01 +FFFFF7FFFFFFFFFF D5000000_01 +07FFF80000000002 5CFFFF01_01 +0000000010A1E5B8 4D850F2E_01 +FFFFEFFFFFFFFFFF D5800000_01 +F7FFFFE00007FFFF DD000001_01 +FFFFFFFFFFF6ADFC C9152040_00 +FFFFDFFFFFFFFFFF D6000000_01 +FFFFFF03FFFFFFC0 D37C0000_01 +EA579475948F0032 DDAD435C_01 +FFFFBFFFFFFFFFFF D6800000_01 +FC00000000003FF6 DC7FFFFF_01 +002E677AC313BF60 5A399DEC_01 +FFFF7FFFFFFFFFFF D7000000_01 +02000007FF7FFFFF 5C000002_01 +0000000E999639F1 51699964_01 +FFFEFFFFFFFFFFFF D7800000_01 +FFFF83FFFFFFFFBE D6F80000_01 +000000000001537D 47A9BE80_00 +FFFDFFFFFFFFFFFF D8000000_01 +EFFFFFC00000003D DD800001_01 +FFFFFFF21FEDFD35 D15E0120_01 +FFFBFFFFFFFFFFFF D8800000_01 +FFFFFFF0000007FE D17FFFFF_01 +FFFFFFFFFFDE0839 CA07DF1C_00 +FFF7FFFFFFFFFFFF D9000000_01 +0000007FFFE000FF 52FFFFC1_01 +FFFFFFFF79F30F48 CF060CF0_01 +FFEFFFFFFFFFFFFF D9800000_01 +FFFFFC13FFFFFFFD D47B0000_01 +0000000000001B85 45DC2800_00 +FFDFFFFFFFFFFFFF DA000000_01 +000008000007FFFE 55000001_01 +12DB4409E5AE87E6 5D96DA21_01 +FFBFFFFFFFFFFFFF DA800000_01 +FFFFFFFFFFF7BFEE C9040120_00 +FFFFFFFFFFFFFFFD C0400000_00 +FF7FFFFFFFFFFFFF DB000000_01 +000000001040FFFE 4D820800_01 +00000909A09C13D3 55109A0A_01 +FEFFFFFFFFFFFFFF DB800000_01 +FFFFFF01FFFFFF7F D37E0000_01 +FFFFFF72E7D2575D D30D182D_01 +FDFFFFFFFFFFFFFF DC000000_01 +FFFFFFFFFFFEFFDB C7801280_00 +0000000000000017 41B80000_00 +FBFFFFFFFFFFFFFF DC800000_01 +100000001FFFFFF6 5D800001_01 +000000114B12EF51 518A5898_01 +F7FFFFFFFFFFFFFF DD000000_01 +0407FFFFFFFFFEFF 5C810000_01 +FFFFFF769F3A5C2C D30960C5_01 +EFFFFFFFFFFFFFFF DD800000_01 +FFFFFFFDF7FFFFFD D0020000_01 +FFFFFFFFFFFFFFF2 C1600000_00 +DFFFFFFFFFFFFFFF DE000000_01 +FFFFFFFFFE0007FF CBFFFC00_01 +000000000000001E 41F00000_00 +BFFFFFFFFFFFFFFF DE800000_01 +FFF800000009FFFF D8FFFFFF_01 +0000000000007AA4 46F54800_00 +7FFFFFFFFFFFFFFF 5F000000_01 +4080000000FFFFFF 5E810001_01 +000000000DE7601D 4D5E7602_01 +3FFFFFFFFFFFFFFF 5E800000_01 +FFCFFFFFFFBFFFFE DA400000_01 +FFFFFFFFFFFFFFCA C2580000_00 +1FFFFFFFFFFFFFFF 5E000000_01 +000080400000003F 57004001_01 +00000000001F75A5 49FBAD28_00 +0FFFFFFFFFFFFFFF 5D800000_01 +FFFFFFEFFFFFCFFE D1800001_01 +FFFFFEE775887420 D38C453B_01 +07FFFFFFFFFFFFFF 5D000000_01 +00000000000801FE 49001FE0_00 +0000000000213FF1 4A04FFC4_00 +03FFFFFFFFFFFFFF 5C800000_01 +07FEFFFFFFFFFFEE 5CFFE000_01 +0000000000000004 40800000_00 +01FFFFFFFFFFFFFF 5C000000_01 +0000000820000003 51020001_01 +FFFFFFF9AD105214 D0CA5DF5_01 +00FFFFFFFFFFFFFF 5B800000_01 +FFFFF00FFFFFFFBE D57F0000_01 +FFFFFFFFFFCC48E7 CA4EDC64_00 +007FFFFFFFFFFFFF 5B000000_01 +00000FFFEF7FFFFF 557FFEF8_01 +FFFFFFFFFF0BA6CB CB745935_00 +003FFFFFFFFFFFFF 5A800000_01 +FFFFFF7FBFFFFFBF D3004000_01 +FFFFFFFFFFF24425 C95BBDB0_00 +001FFFFFFFFFFFFF 5A000000_01 +200000001FFBFFFF 5E000001_01 +FFFFFF4E7115EC53 D3318EEA_01 +000FFFFFFFFFFFFF 59800000_01 +FFFFF803FFFFFFBF D4FF8000_01 +FFFFFC2E539ADCFE D4746B19_01 +0007FFFFFFFFFFFF 59000000_01 +FFFFFFFFFBFFFFFF CC800000_01 +00000055084732F3 52AA108F_01 +0003FFFFFFFFFFFF 58800000_01 +BFFF7FFFFFFFFE00 DE800100_01 +FFFFFFFFFFFF8543 C6F57A00_00 +0001FFFFFFFFFFFF 58000000_01 +0000001FFBFFE000 51FFDFFF_00 +FFFFFFFFFFFE491B C7DB7280_00 +0000FFFFFFFFFFFF 57800000_01 +FC00200000001FFE DC7FF7FF_01 +FFFFF16898822A24 D5697677_01 +00007FFFFFFFFFFF 57000000_01 +3FFF03FFFFFFFFFE 5E7FFC10_01 +FFFFFF8FFE18C7BF D2E003CE_01 +00003FFFFFFFFFFF 56800000_01 +FFFFFEFFFEFFFFFD D3800080_01 +00F03620C1266ED9 5B703621_01 +00001FFFFFFFFFFF 56000000_01 +BF7EFFFFFFFFFFFF DE810200_01 +FFFFFFFFFFFFFFD5 C22C0000_00 +00000FFFFFFFFFFF 55800000_01 +FFFBFFFFF803FFFE D8800000_01 +0000000000068684 48D0D080_00 +000007FFFFFFFFFF 55000000_01 +DFFFFFE00000001E DE000000_01 +FFFFFFFFFFFFECF5 C5985800_00 +000003FFFFFFFFFF 54800000_01 +FFFF00400000FFFF D77FBFFF_01 +0000000000000002 40000000_00 +000001FFFFFFFFFF 54000000_01 +FBFFFFFFFFFFBDFE DC800000_01 +0000000000000BC9 453C9000_00 +000000FFFFFFFFFF 53800000_01 +807FFFFFFFFFDFFE DEFF0000_01 +FFC274E35A70CD76 DA762C72_01 +0000007FFFFFFFFF 53000000_01 +0FFFFFFFFEFFFFFD 5D800000_01 +FFFFFFFF00E73AFC CF7F18C5_01 +0000003FFFFFFFFF 52800000_01 +FFC000000001000E DA7FFFFF_01 +FFFFFFFFFFFE15E9 C7F50B80_00 +0000001FFFFFFFFF 52000000_01 +0001FFFFFFFFF3FD 58000000_01 +0000000000000033 424C0000_00 +0000000FFFFFFFFF 51800000_01 +000000001FFFBFFF 4DFFFE00_01 +FFFFFFEE6B141E1B D18CA75F_01 +00000007FFFFFFFF 51000000_01 +FFFFFFFFF60007FF CD1FFF80_01 +00000001AB310BA6 4FD59886_01 +00000003FFFFFFFF 50800000_01 +0003FFFFB7FFFFFF 587FFFEE_01 +FFFFFFFFFFFFF195 C566B000_00 +00000001FFFFFFFF 50000000_01 +FFFFFFFF8000000B CEFFFFFF_01 +00000019BA8D5559 51CDD46B_01 +00000000FFFFFFFF 4F800000_01 +FBFEFFFFFFFFFFF9 DC802000_01 +FFFFFFB6F062822D D2921F3A_01 +000000007FFFFFFF 4F000000_01 +0001000000000082 57800001_01 +01CEAD9E2FB104A4 5BE756D0_01 +000000003FFFFFFF 4E800000_01 +000003FFFFFFFF7C 54800000_01 +FFFFFFFFFD681E78 CC25F862_00 +000000001FFFFFFF 4E000000_01 +00002000400001FF 56000101_01 +0000000000000018 41C00000_00 +000000000FFFFFFF 4D800000_01 +3FFF80000000003E 5E7FFE01_01 +FFFFFFFFFFFFFF95 C2D60000_00 +0000000007FFFFFF 4D000000_01 +010000BFFFFFFFFF 5B800060_01 +0000001697087B19 51B4B844_01 +0000000003FFFFFF 4C800000_01 +FBFFFFFFFFEEFFFD DC800000_01 +0000000E64BDFC55 51664BE0_01 +0000000001FFFFFF 4C000000_01 +FC00000001FFFFFE DC7FFFFF_01 +FFFED156A62AB849 D79754AC_01 +0000000000FFFFFF 4B7FFFFF_00 +FFFFFFF83FEFFFFD D0F80200_01 +00015354EAE7C259 57A9AA76_01 +00000000007FFFFF 4AFFFFFE_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFF0F4DF3C75 D170B20C_01 +00000000003FFFFF 4A7FFFFC_00 +FFFA000000001FFF D8BFFFFF_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000001FFFFF 49FFFFF8_00 +FFFFFFFFFF7FFE40 CB0001C0_00 +FFFFFFDB5433CB9B D212AF30_01 +00000000000FFFFF 497FFFF0_00 +FFFFFDFFDFFDFFFD D4000800_01 +FFFFFFFFFFDEAE1F CA054784_00 +000000000007FFFF 48FFFFE0_00 +FFFFFFFFF0080006 CD7F7FFF_01 +FFFFFFFE7735DEC7 CFC46510_01 +000000000003FFFF 487FFFC0_00 +00000001FBFFFFFF 4FFE0000_01 +000003757D8B12ED 545D5F63_01 +000000000001FFFF 47FFFF80_00 +FFFFFE07F7FFFFFF D3FC0400_01 +00000A654064E046 55265407_01 +000000000000FFFF 477FFF00_00 +08000000000017FF 5D000001_01 +FFFFFFFFFFFFFFE7 C1C80000_00 +0000000000007FFF 46FFFE00_00 +07FFFFFFFFFFFDF6 5D000000_01 +FFFFAD78B3D6C3B6 D6A50E98_01 +0000000000003FFF 467FFC00_00 +0000300004000000 56400010_00 +FFFFFFF70B77F34F D10F4880_01 +0000000000001FFF 45FFF800_00 +FFFFFF80006FFFFE D2FFFF20_01 +0000013EB4D67EC8 539F5A6C_01 +0000000000000FFF 457FF000_00 +BFFFDFFFFBFFFFFF DE800040_01 +0005CEAF34EA1DC7 58B9D5E7_01 +00000000000007FF 44FFE000_00 +00004800007FFFFD 56900001_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000000003FF 447FC000_00 +0000000200001000 50000004_00 +00000000000360D0 48583400_00 +00000000000001FF 43FF8000_00 +01003FFFFFFFFFFC 5B802000_01 +00C000708FF1BA51 5B400071_01 +00000000000000FF 437F0000_00 +F802000003FFFFFF DCFFBFFF_01 +0F9E07DCC0BDC061 5D79E07E_01 +000000000000007F 42FE0000_00 +03FF0000000000FF 5C7FC001_01 +FFFFFFE1B9B2A079 D1F2326A_01 +000000000000003F 427C0000_00 +FFF80000000080FF D8FFFFFF_01 +00000000001EB5B4 49F5ADA0_00 +000000000000001F 41F80000_00 +000000000077FBFE 4AEFF7FC_00 +00000000005AC607 4AB58C0E_00 +000000000000000F 41700000_00 +FFFFFFFEF80000FF CF83FFFF_01 +000005C5B9D66984 54B8B73B_01 +0000000000000007 40E00000_00 +C001FFFFFFF00000 DE7FF800_01 +00001D06B372AA06 55E8359C_01 +0000000000000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_rz.tv b/wally-pipelined/testbench/fp/i64_f32_rz.tv new file mode 100644 index 000000000..b996cbb7a --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f32_rz.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 5CFFFFBF_01 +0000000032CC8B7A 4E4B322D_01 +0000000000000000 00000000_00 +FFFFFFFFC0003FFE CE7FFF00_01 +032C857F319EDE38 5C4B215F_01 +0000000000000001 3F800000_00 +FFFFFBFFFFF8003E D4800000_01 +00394C79B6D3007B 5A6531E6_01 +0000000000000002 40000000_00 +FBFFFFF0000001FF DC800001_01 +0000000001AE458D 4BD722C6_01 +0000000000000004 40800000_00 +00040008000007FE 58800100_01 +F9EB456140D88764 DCC29753_01 +0000000000000008 41000000_00 +FFFFE400FFFFFFFE D5DFF800_01 +07DE834A248EDF36 5CFBD069_01 +0000000000000010 41800000_00 +00000003FF001FFF 507FC007_01 +FFFFFFFFFFE385E2 C9E3D0F0_00 +0000000000000020 42000000_00 +F0041FFFFFFFFFFF DD7FBE00_01 +000000059EB1FD45 50B3D63F_01 +0000000000000040 42800000_00 +FFFFFFFFFFFCFFF9 C84001C0_00 +FFFFFFFFFFFEDDFE C7910100_00 +0000000000000080 43000000_00 +000000000003FF00 487FC000_00 +00000000C89FF56B 4F489FF5_01 +0000000000000100 43800000_00 +000FFFFF7FDFFFFF 597FFFF7_01 +1B5E4F0BE0DEBFF0 5DDAF278_01 +0000000000000200 44000000_00 +FFFDF803FFFFFFFF D801FF00_01 +FFFFFFFFFFF4766B C9389950_00 +0000000000000400 44800000_00 +0000080100000FFE 55001000_01 +000000000000000C 41400000_00 +0000000000000800 45000000_00 +0048000000100000 5A900000_01 +FFE662A109109D0A D9CCEAF7_01 +0000000000001000 45800000_00 +C000000037FFFFFE DE7FFFFF_01 +FFFFFFFFFFFFFFE4 C1E00000_00 +0000000000002000 46000000_00 +F801000000100000 DCFFDFFF_01 +FE114B79075F70EE DBF75A43_01 +0000000000004000 46800000_00 +100000000001003E 5D800000_01 +00000000000003AC 446B0000_00 +0000000000008000 47000000_00 +200000FFFFFFF800 5E000003_01 +00000044A3A3DBE5 52894747_01 +0000000000010000 47800000_00 +FFE0003EFFFFFFFF D9FFFE08_01 +FFFFFFFFFFFF1A91 C7656F00_00 +0000000000020000 48000000_00 +FFFFF7C3FFFFFFFD D503C000_01 +0000000000003309 464C2400_00 +0000000000040000 48800000_00 +000083FFF7FFFFFE 5703FFF7_01 +FFFFFFFFFFFFFF58 C3280000_00 +0000000000080000 49000000_00 +FFFFFFDE01FFFFFE D207F800_01 +0000000000002980 46260000_00 +0000000000100000 49800000_00 +00000000FFF07FFF 4F7FF07F_01 +000000000000005D 42BA0000_00 +0000000000200000 4A000000_00 +000020FFDFFFFFFF 5603FF7F_01 +FFFC8C23DA2CEAD8 D85CF709_01 +0000000000400000 4A800000_00 +E0000000003FFFDF DDFFFFFF_01 +FFFFFDE3C1DEC43C D4070F88_01 +0000000000800000 4B000000_00 +FFFF00000BFFFFFD D77FFFF4_01 +000000000030FFBE 4A43FEF8_00 +0000000001000000 4B800000_00 +FFFE000007FFEFFD D7FFFFFC_01 +FFFFFFFFEFDEED86 CD810893_01 +0000000002000000 4C000000_00 +F3FFFFFFFFBFFFFE DD400000_01 +000000001DA3FF45 4DED1FFA_01 +0000000004000000 4C800000_00 +FFFFFFFF00010007 CF7FFEFF_01 +FFFFFFFE9B1BCB54 CFB2721A_01 +0000000008000000 4D000000_00 +00004000004001FE 56800000_01 +F27DD19DE6563714 DD5822E6_01 +0000000010000000 4D800000_00 +FFC00000004007FE DA7FFFFF_01 +000000000001A359 47D1AC80_00 +0000000020000000 4E000000_00 +0000000003C000FE 4C70003F_01 +FFFFFFFFFE62EC20 CBCE89F0_00 +0000000040000000 4E800000_00 +000000003FFFFFFD 4E7FFFFF_01 +000000000000285F 46217C00_00 +0000000080000000 4F000000_00 +FFFFFFFFBFFFF00F CE80001F_01 +FFFFF836F99DBAA8 D4F920CC_01 +0000000100000000 4F800000_00 +00000020003FFEFE 520000FF_01 +0033466832042D47 5A4D19A0_01 +0000000200000000 50000000_00 +FFFFFFFFFFFFF887 C4EF2000_00 +00000000003829C8 4A60A720_00 +0000000400000000 50800000_00 +00000FFFFFFF7DFD 557FFFFF_01 +0000000FB77C672B 517B77C6_01 +0000000800000000 51000000_00 +08003FFDFFFFFFFE 5D0003FF_01 +0000000000001B78 45DBC000_00 +0000001000000000 51800000_00 +FF7FFFFFFFEFDFFF DB000000_01 +0000000000000071 42E20000_00 +0000002000000000 52000000_00 +000013FFFFFFFDFF 559FFFFF_01 +FFFFFFFFFFFFFF86 C2F40000_00 +0000004000000000 52800000_00 +0800000000040800 5D000000_01 +FFF8A60D9E19F17E D8EB3E4C_01 +0000008000000000 53000000_00 +000077FFF0000000 56EFFFE0_00 +FFFFFFFFF7506DBA CD0AF924_01 +0000010000000000 53800000_00 +FFFFFFFFFFFEFBF7 C7820480_00 +FFFFFFFFFEA42AC9 CBADEA9B_01 +0000020000000000 54000000_00 +0000107FFFFFDFFD 5583FFFF_01 +FFE7AA3F2BDACC89 D9C2AE06_01 +0000040000000000 54800000_00 +FFF8040000040000 D8FF7FFF_01 +FFFFFFFFFFFFFFFD C0400000_00 +0000080000000000 55000000_00 +FFFF80000800001F D6FFFFEF_01 +FFFDF681DECDADC9 D8025F88_01 +0000100000000000 55800000_00 +FFFFFEFFFFE0007F D380000F_01 +FFFFFFFFFFFFCFBE C6410800_00 +0000200000000000 56000000_00 +0000000901FFFFFD 51101FFF_01 +FEC01FECA24DE1B0 DB9FF009_01 +0000400000000000 56800000_00 +F7FFFFFFDFFF7FFF DD000000_01 +F858A66761669936 DCF4EB33_01 +0000800000000000 57000000_00 +FFFEFF800000003E D7803FFF_01 +F716EA43FAC45C97 DD0E915B_01 +0001000000000000 57800000_00 +FFFFFFFFFFFFFFC6 C2680000_00 +0024D70EC7661FD8 5A135C3B_01 +0002000000000000 58000000_00 +C07FFFFFFFFFFFFE DE7E0000_01 +FFD956DBD0AEE817 DA1AA490_01 +0004000000000000 58800000_00 +020003EFFFFFFFFE 5C0000FB_01 +FFFFFFFFFFFF4300 C73D0000_00 +0008000000000000 59000000_00 +4000000004002000 5E800000_01 +C12EDF40F41F6021 DE7B4482_01 +0010000000000000 59800000_00 +FF9000000000001D DADFFFFF_01 +FFFFFFF83DE950F6 D0F842D5_01 +0020000000000000 5A000000_00 +800003FFFFFC0000 DEFFFFF8_01 +FE2B59CB3A604D69 DBEA531A_01 +0040000000000000 5A800000_00 +7FFFFFFDFFFFBFFF 5EFFFFFF_01 +000000A37C210862 53237C21_01 +0080000000000000 5B000000_00 +0002000002000002 58000000_01 +FFFFB65CD8617789 D693464F_01 +0100000000000000 5B800000_00 +00001BFFFFFFBFFE 55DFFFFF_01 +FFFFFFFFFFFFF01D C57E3000_00 +0200000000000000 5C000000_00 +1000008000003FFF 5D800004_01 +000000000D098D19 4D5098D1_01 +0400000000000000 5C800000_00 +03FFFFFFFFFFF5FF 5C7FFFFF_01 +000006B3BD2C7BEF 54D677A5_01 +0800000000000000 5D000000_00 +00003FFFBFFFFFFE 567FFEFF_01 +FFFF4E5ADDDAA4A8 D731A522_01 +1000000000000000 5D800000_00 +001FFFC000000FFD 59FFFE00_01 +FFFFFFFFFFFFFF21 C35F0000_00 +2000000000000000 5E000000_00 +0000000041DFFFFF 4E83BFFF_01 +FFFFFFFFFC648262 CC66DF67_01 +4000000000000000 5E800000_00 +C0001FFFFFFFFFFB DE7FFF80_01 +FFFFFF7353AC45D2 D30CAC53_01 +8000000000000000 DF000000_00 +FFFFFFFFFFE7EFFF C9C08008_00 +0000000000A1202D 4B21202D_00 +C000000000000000 DE800000_00 +FFFFFFFFFFFF5F7F C7208100_00 +000000000040CA70 4A8194E0_00 +E000000000000000 DE000000_00 +0000200201FFFFFE 56000807_01 +00000003B55D87D4 506D5761_01 +F000000000000000 DD800000_00 +FF80000DFFFFFFFF DAFFFFE4_01 +000000010510FAEF 4F82887D_01 +F800000000000000 DD000000_00 +0003FFF00000000F 587FFC00_01 +000000000000724A 46E49400_00 +FC00000000000000 DC800000_00 +FFFFFFDF80000002 D201FFFF_01 +0000000000000064 42C80000_00 +FE00000000000000 DC000000_00 +FEFFFFFFFFF800FE DB800000_01 +FFFFFFC2C6222702 D274E777_01 +FF00000000000000 DB800000_00 +0000000408000002 50810000_01 +000000E96DF1CB41 53696DF1_01 +FF80000000000000 DB000000_00 +007FFFFFFFFFF9FE 5AFFFFFF_01 +F727F174DEE7DC85 DD0D80E8_01 +FFC0000000000000 DA800000_00 +8000000003FFFEFE DEFFFFFF_01 +FFFFFFFFFFF0BD5B C9742A50_00 +FFE0000000000000 DA000000_00 +0BEFFFFFFFFFFFFF 5D3EFFFF_01 +000000000002790C 481E4300_00 +FFF0000000000000 D9800000_00 +FFFFFFFFFFEFFBFA C9802030_00 +000000169E75DF01 51B4F3AE_01 +FFF8000000000000 D9000000_00 +00000007FEFFDFFF 50FFDFFB_01 +000000000000000E 41600000_00 +FFFC000000000000 D8800000_00 +0003FFFE0007FFFE 587FFF80_01 +FFFFFFFFFFF28622 C9579DE0_00 +FFFE000000000000 D8000000_00 +FFFFFF7FFFFDF7FF D3000002_01 +00072F0EC496FE21 58E5E1D8_01 +FFFF000000000000 D7800000_00 +DFBFFFFFFFFFFFFE DE010000_01 +0000000000FC1FCA 4B7C1FCA_00 +FFFF800000000000 D7000000_00 +00000FFF800FFFFE 557FF800_01 +FFFF5194E4A9C2CE D72E6B1B_01 +FFFFC00000000000 D6800000_00 +00000002100007FD 50040001_01 +FFFFFFFFFFC2D8FE CA749C08_00 +FFFFE00000000000 D6000000_00 +000000000007FF6E 48FFEDC0_00 +000000000001766E 47BB3700_00 +FFFFF00000000000 D5800000_00 +0040000400000002 5A800008_01 +0000000000007841 46F08200_00 +FFFFF80000000000 D5000000_00 +3DFFFFFFFFFFFF7E 5E77FFFF_01 +FFFFFFE549E17E30 D1D5B0F4_01 +FFFFFC0000000000 D4800000_00 +FFFFFFFFFFFFFEE1 C38F8000_00 +FFFFFFFFFFFFFFE7 C1C80000_00 +FFFFFE0000000000 D4000000_00 +000000000EFFFFDF 4D6FFFFD_01 +FFFFFFFFFFFFFF73 C30D0000_00 +FFFFFF0000000000 D3800000_00 +FD00000008000000 DC3FFFFF_01 +000000000001DBB1 47EDD880_00 +FFFFFF8000000000 D3000000_00 +FFFFFFFFFFF8007F C8FFF020_00 +FFFFFFFEFD10A515 CF8177AD_01 +FFFFFFC000000000 D2800000_00 +FFEFFFFFFFFFFFFE D9800000_01 +FAB02984F6283B6C DCA9FACF_01 +FFFFFFE000000000 D2000000_00 +FFFFFFBC000001FE D287FFFF_01 +FEB087C6B9FE7FE0 DBA7BC1C_01 +FFFFFFF000000000 D1800000_00 +FFF80001000007FE D8FFFFDF_01 +00F2762EA6837956 5B72762E_01 +FFFFFFF800000000 D1000000_00 +FFF7E0FFFFFFFFFE D901F000_01 +00002E1175484626 563845D5_01 +FFFFFFFC00000000 D0800000_00 +0000200020000FFE 56000080_01 +000000000000068F 44D1E000_00 +FFFFFFFE00000000 D0000000_00 +021FFFFFFFFBFFFF 5C07FFFF_01 +FFFFFFFFFFFFFFF9 C0E00000_00 +FFFFFFFF00000000 CF800000_00 +FFFFFFD0000FFFFD D23FFFC0_01 +000000BDF6658B83 533DF665_01 +FFFFFFFF80000000 CF000000_00 +1000001FFDFFFFFF 5D800000_01 +0000000000003B5B 466D6C00_00 +FFFFFFFFC0000000 CE800000_00 +FFFFFFBFFE0FFFFF D28003E0_01 +FFFFFFFFFFFFFFF0 C1800000_00 +FFFFFFFFE0000000 CE000000_00 +FFFFFFFBF00007FF D081FFFF_01 +01E986274F48EAAD 5BF4C313_01 +FFFFFFFFF0000000 CD800000_00 +1FFFFFFDFFFFFF7F 5DFFFFFF_01 +FFFFFFFFFFFFCB5A C6529800_00 +FFFFFFFFF8000000 CD000000_00 +7FF000000000FFFF 5EFFE000_01 +00000003C2717FC3 50709C5F_01 +FFFFFFFFFC000000 CC800000_00 +FFFFFFE00008001F D1FFFFBF_01 +FFFFFFFFFFEFABDA C982A130_00 +FFFFFFFFFE000000 CC000000_00 +0200000000000002 5C000000_01 +FFFFFFFFF8FDA53F CCE04B58_01 +FFFFFFFFFF000000 CB800000_00 +F6000003FFFFFFFE DD1FFFFF_01 +FFFFFFFFFFFFFFD0 C2400000_00 +FFFFFFFFFF800000 CB000000_00 +FFFFFFFFFFBFFF7E CA800104_00 +00000000EE0FEA62 4F6E0FEA_01 +FFFFFFFFFFC00000 CA800000_00 +0000007FFF9FFFFD 52FFFF3F_01 +00000037F35EDC1D 525FCD7B_01 +FFFFFFFFFFE00000 CA000000_00 +FFFFFFF7FDFFFF7D D1002000_01 +00000000000001AD 43D68000_00 +FFFFFFFFFFF00000 C9800000_00 +FFFFFF0000100020 D37FFFEF_01 +27F167FBC7FC5F9A 5E1FC59F_01 +FFFFFFFFFFF80000 C9000000_00 +003FFFFFFFFC0001 5A7FFFFF_01 +000E48F9F4EBD30E 59648F9F_01 +FFFFFFFFFFFC0000 C8800000_00 +DFFFFFFFFFFBFFFE DE000000_01 +FC91C23EE8C9424F DC5B8F70_01 +FFFFFFFFFFFE0000 C8000000_00 +F7DFFBFFFFFFFFFE DD020040_01 +000000002CAE080C 4E32B820_01 +FFFFFFFFFFFF0000 C7800000_00 +FFFFC00010000020 D67FFFBF_01 +04D921F917B20E40 5C9B243F_01 +FFFFFFFFFFFF8000 C7000000_00 +F8000FFFFFFFFFFD DCFFFE00_01 +FFF17C566BC7D811 D9683A99_01 +FFFFFFFFFFFFC000 C6800000_00 +00000000000000FE 437E0000_00 +FFF82AC14930D386 D8FAA7D6_01 +FFFFFFFFFFFFE000 C6000000_00 +00000000000003FC 447F0000_00 +000E62EC60E119FC 59662EC6_01 +FFFFFFFFFFFFF000 C5800000_00 +FFFFEFF7FF7FFFFE D5804004_01 +0E2B1ECF210EEDC5 5D62B1EC_01 +FFFFFFFFFFFFF800 C5000000_00 +00000000007FFF1F 4AFFFE3E_00 +FFFFFE534F5676F7 D3D65854_01 +FFFFFFFFFFFFFC00 C4800000_00 +0000001004FFFFFD 518027FF_01 +0000035C939669F1 545724E5_01 +FFFFFFFFFFFFFE00 C4000000_00 +1FFFFFFFFFFFFDFD 5DFFFFFF_01 +FFFFFFFFFFFFFF91 C2DE0000_00 +FFFFFFFFFFFFFF00 C3800000_00 +01FFFFFFFBFFEFFE 5BFFFFFF_01 +000000000000016E 43B70000_00 +FFFFFFFFFFFFFF80 C3000000_00 +FFF7FFFFFFFFF7FD D9000000_01 +FFFFF8E2BCFAC553 D4E3A860_01 +FFFFFFFFFFFFFFC0 C2800000_00 +FFFFFBFFFFFE0FFE D4800000_01 +00000001A4E704BF 4FD27382_01 +FFFFFFFFFFFFFFE0 C2000000_00 +1400007FFFFFFFFD 5DA00003_01 +FFFFFFFC93B187B4 D05B139E_01 +FFFFFFFFFFFFFFF0 C1800000_00 +40000000007FFFFD 5E800000_01 +000000000067D468 4ACFA8D0_00 +FFFFFFFFFFFFFFF8 C1000000_00 +007FFEFFFFFBFFFE 5AFFFDFF_01 +FFFFFFE26CEC79F8 D1EC989C_01 +FFFFFFFFFFFFFFFC C0800000_00 +00FFFFFF000000FF 5B7FFFFF_01 +FFFFFFFFE0D3983A CDF9633E_01 +FFFFFFFFFFFFFFFE C0000000_00 +00007FFFBFFF7FFE 56FFFF7F_01 +FFFFFFFDF4A7088A D002D63D_01 +FFFFFFFFFFFFFFFF BF800000_00 +000008000000027E 55000000_01 +000000000000F4E8 4774E800_00 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFF83FFDF CAF80042_00 +00000E11407887B2 55611407_01 +FFFFFFFFFFFFFFFB C0A00000_00 +04000003FFFFFFF6 5C800000_01 +0000000000000513 44A26000_00 +FFFFFFFFFFFFFFF7 C1100000_00 +BFFC00000000003E DE8007FF_01 +00000008D7BBB75B 510D7BBB_01 +FFFFFFFFFFFFFFEF C1880000_00 +000FFFFBFFFC0000 597FFFBF_01 +FFFFFFFFFFCD5A23 CA4A9774_00 +FFFFFFFFFFFFFFDF C2040000_00 +FFBFDFFFBFFFFFFF DA804000_01 +000000000000007F 42FE0000_00 +FFFFFFFFFFFFFFBF C2820000_00 +00000007FF800003 50FFF000_01 +000000000002BB02 482EC080_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEE7FF C78C0080_00 +00264B2B9BAD0DA2 5A192CAE_01 +FFFFFFFFFFFFFEFF C3808000_00 +0000000000100803 49804018_00 +FF9B1DCB9F857D5E DAC9C468_01 +FFFFFFFFFFFFFDFF C4004000_00 +FFFFFFBFFFFFEFEE D2800000_01 +F6FD7542899C1C6F DD1028AB_01 +FFFFFFFFFFFFFBFF C4802000_00 +FF800000004001FF DAFFFFFF_01 +0000000002BE4932 4C2F924C_01 +FFFFFFFFFFFFF7FF C5001000_00 +00001004000FFFFE 55802000_01 +FFFFFF9DAA0123E0 D2C4ABFD_01 +FFFFFFFFFFFFEFFF C5800800_00 +00000001FDFFFDFE 4FFEFFFE_01 +FFFC1C8703B1DCB0 D878DE3F_01 +FFFFFFFFFFFFDFFF C6000400_00 +FE0FE00000000000 DBF81000_00 +0779ED944A4E2779 5CEF3DB2_01 +FFFFFFFFFFFFBFFF C6800200_00 +FBFFFE0400000000 DC80003F_01 +0000010127E03666 538093F0_01 +FFFFFFFFFFFF7FFF C7000100_00 +FFFFF0200000FFFE D57DFFFF_01 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFFFFFFEFFFF C7800080_00 +FFEFFE0000080000 D9800FFF_01 +FFFFFFFFFD3354EA CC332AC5_01 +FFFFFFFFFFFDFFFF C8000040_00 +003FF0000003FFFE 5A7FC000_01 +0000006375B23F7B 52C6EB64_01 +FFFFFFFFFFFBFFFF C8800020_00 +000407FFFFFFFFF6 5880FFFF_01 +0000000092117F38 4F12117F_01 +FFFFFFFFFFF7FFFF C9000010_00 +FFFFFFFFFFFF7FFF C7000100_00 +00000000000008BE 450BE000_00 +FFFFFFFFFFEFFFFF C9800008_00 +004000020FFFFFFF 5A800004_01 +FFFFB84C2D8BC9CB D68F67A4_01 +FFFFFFFFFFDFFFFF CA000004_00 +00FFFFFFFFFFFFFD 5B7FFFFF_01 +00000023C2C6F284 520F0B1B_01 +FFFFFFFFFFBFFFFF CA800002_00 +FFFDDFFFFFFFFFFD D8080000_01 +00000000746356C4 4EE8C6AD_01 +FFFFFFFFFF7FFFFF CB000001_00 +010000000000BFFF 5B800000_01 +FFFFFFFFFFFFFFFD C0400000_00 +FFFFFFFFFEFFFFFF CB800000_01 +FFFFBF7FFBFFFFFE D6810008_01 +00000006386CE889 50C70D9D_01 +FFFFFFFFFDFFFFFF CC000000_01 +F00000F7FFFFFFFF DD7FFFF0_01 +FFFDFC53090C46A4 D800EB3D_01 +FFFFFFFFFBFFFFFF CC800000_01 +0000000000800047 4B000047_00 +FFFFFFFFD693872E CE25B1E3_01 +FFFFFFFFF7FFFFFF CD000000_01 +000000007FBFFBFF 4EFF7FF7_01 +00000026A7845E35 521A9E11_01 +FFFFFFFFEFFFFFFF CD800000_01 +FFFFFFDFFFFFFBFD D2000000_01 +000000001433D14C 4DA19E8A_01 +FFFFFFFFDFFFFFFF CE000000_01 +0001FFFFFFE0000E 57FFFFFF_01 +F0F23E8068D3D84A DD70DC17_01 +FFFFFFFFBFFFFFFF CE800000_01 +F7FFBFFFFFFFBFFF DD000400_01 +FFFFBD29B7459087 D685AC91_01 +FFFFFFFF7FFFFFFF CF000000_01 +FFFFFFF8FFFFBFFF D0E00008_01 +FFFFFFFFFFEDDC06 C9911FD0_00 +FFFFFFFEFFFFFFFF CF800000_01 +FFFFFFF80001FFFF D0FFFFC0_01 +0000000000002FF9 463FE400_00 +FFFFFFFDFFFFFFFF D0000000_01 +004000040000FFFF 5A800008_01 +FFFFFFFFFFFFFFF1 C1700000_00 +FFFFFFFBFFFFFFFF D0800000_01 +C0000000007FFFFA DE7FFFFF_01 +FFFFFFFFFE053E2B CBFD60EA_01 +FFFFFFF7FFFFFFFF D1000000_01 +7FFE000007FFFFFF 5EFFFC00_01 +000000000000000D 41500000_00 +FFFFFFEFFFFFFFFF D1800000_01 +F80000000001007E DCFFFFFF_01 +FFFFED48424AD9D6 D595BDED_01 +FFFFFFDFFFFFFFFF D2000000_01 +FFFFFE0001FEFFFF D3FFFF00_01 +000000000000013B 439D8000_00 +FFFFFFBFFFFFFFFF D2800000_01 +0007FBFFFFFDFFFE 58FF7FFF_01 +4A16BD4128090C83 5E942D7A_01 +FFFFFF7FFFFFFFFF D3000000_01 +00FFF7FFFF7FFFFE 5B7FF7FF_01 +0000000000000006 40C00000_00 +FFFFFEFFFFFFFFFF D3800000_01 +FBFFFFBFFFBFFFFF DC800008_01 +00000000000001BA 43DD0000_00 +FFFFFDFFFFFFFFFF D4000000_01 +0000000040000082 4E800001_01 +FF07A2BF5B689F89 DB785D40_01 +FFFFFBFFFFFFFFFF D4800000_01 +0000001FF8000008 51FFC000_01 +F87CAA7DE672DE8B DCF06AB0_01 +FFFFF7FFFFFFFFFF D5000000_01 +07FFF80000000002 5CFFFF00_01 +0000000010A1E5B8 4D850F2D_01 +FFFFEFFFFFFFFFFF D5800000_01 +F7FFFFE00007FFFF DD000001_01 +FFFFFFFFFFF6ADFC C9152040_00 +FFFFDFFFFFFFFFFF D6000000_01 +FFFFFF03FFFFFFC0 D37C0000_01 +EA579475948F0032 DDAD435C_01 +FFFFBFFFFFFFFFFF D6800000_01 +FC00000000003FF6 DC7FFFFF_01 +002E677AC313BF60 5A399DEB_01 +FFFF7FFFFFFFFFFF D7000000_01 +02000007FF7FFFFF 5C000001_01 +0000000E999639F1 51699963_01 +FFFEFFFFFFFFFFFF D7800000_01 +FFFF83FFFFFFFFBE D6F80000_01 +000000000001537D 47A9BE80_00 +FFFDFFFFFFFFFFFF D8000000_01 +EFFFFFC00000003D DD800001_01 +FFFFFFF21FEDFD35 D15E0120_01 +FFFBFFFFFFFFFFFF D8800000_01 +FFFFFFF0000007FE D17FFFFF_01 +FFFFFFFFFFDE0839 CA07DF1C_00 +FFF7FFFFFFFFFFFF D9000000_01 +0000007FFFE000FF 52FFFFC0_01 +FFFFFFFF79F30F48 CF060CF0_01 +FFEFFFFFFFFFFFFF D9800000_01 +FFFFFC13FFFFFFFD D47B0000_01 +0000000000001B85 45DC2800_00 +FFDFFFFFFFFFFFFF DA000000_01 +000008000007FFFE 55000000_01 +12DB4409E5AE87E6 5D96DA20_01 +FFBFFFFFFFFFFFFF DA800000_01 +FFFFFFFFFFF7BFEE C9040120_00 +FFFFFFFFFFFFFFFD C0400000_00 +FF7FFFFFFFFFFFFF DB000000_01 +000000001040FFFE 4D8207FF_01 +00000909A09C13D3 55109A09_01 +FEFFFFFFFFFFFFFF DB800000_01 +FFFFFF01FFFFFF7F D37E0000_01 +FFFFFF72E7D2575D D30D182D_01 +FDFFFFFFFFFFFFFF DC000000_01 +FFFFFFFFFFFEFFDB C7801280_00 +0000000000000017 41B80000_00 +FBFFFFFFFFFFFFFF DC800000_01 +100000001FFFFFF6 5D800000_01 +000000114B12EF51 518A5897_01 +F7FFFFFFFFFFFFFF DD000000_01 +0407FFFFFFFFFEFF 5C80FFFF_01 +FFFFFF769F3A5C2C D30960C5_01 +EFFFFFFFFFFFFFFF DD800000_01 +FFFFFFFDF7FFFFFD D0020000_01 +FFFFFFFFFFFFFFF2 C1600000_00 +DFFFFFFFFFFFFFFF DE000000_01 +FFFFFFFFFE0007FF CBFFFC00_01 +000000000000001E 41F00000_00 +BFFFFFFFFFFFFFFF DE800000_01 +FFF800000009FFFF D8FFFFFF_01 +0000000000007AA4 46F54800_00 +7FFFFFFFFFFFFFFF 5EFFFFFF_01 +4080000000FFFFFF 5E810000_01 +000000000DE7601D 4D5E7601_01 +3FFFFFFFFFFFFFFF 5E7FFFFF_01 +FFCFFFFFFFBFFFFE DA400000_01 +FFFFFFFFFFFFFFCA C2580000_00 +1FFFFFFFFFFFFFFF 5DFFFFFF_01 +000080400000003F 57004000_01 +00000000001F75A5 49FBAD28_00 +0FFFFFFFFFFFFFFF 5D7FFFFF_01 +FFFFFFEFFFFFCFFE D1800001_01 +FFFFFEE775887420 D38C453B_01 +07FFFFFFFFFFFFFF 5CFFFFFF_01 +00000000000801FE 49001FE0_00 +0000000000213FF1 4A04FFC4_00 +03FFFFFFFFFFFFFF 5C7FFFFF_01 +07FEFFFFFFFFFFEE 5CFFDFFF_01 +0000000000000004 40800000_00 +01FFFFFFFFFFFFFF 5BFFFFFF_01 +0000000820000003 51020000_01 +FFFFFFF9AD105214 D0CA5DF5_01 +00FFFFFFFFFFFFFF 5B7FFFFF_01 +FFFFF00FFFFFFFBE D57F0000_01 +FFFFFFFFFFCC48E7 CA4EDC64_00 +007FFFFFFFFFFFFF 5AFFFFFF_01 +00000FFFEF7FFFFF 557FFEF7_01 +FFFFFFFFFF0BA6CB CB745935_00 +003FFFFFFFFFFFFF 5A7FFFFF_01 +FFFFFF7FBFFFFFBF D3004000_01 +FFFFFFFFFFF24425 C95BBDB0_00 +001FFFFFFFFFFFFF 59FFFFFF_01 +200000001FFBFFFF 5E000000_01 +FFFFFF4E7115EC53 D3318EEA_01 +000FFFFFFFFFFFFF 597FFFFF_01 +FFFFF803FFFFFFBF D4FF8000_01 +FFFFFC2E539ADCFE D4746B19_01 +0007FFFFFFFFFFFF 58FFFFFF_01 +FFFFFFFFFBFFFFFF CC800000_01 +00000055084732F3 52AA108E_01 +0003FFFFFFFFFFFF 587FFFFF_01 +BFFF7FFFFFFFFE00 DE800100_01 +FFFFFFFFFFFF8543 C6F57A00_00 +0001FFFFFFFFFFFF 57FFFFFF_01 +0000001FFBFFE000 51FFDFFF_00 +FFFFFFFFFFFE491B C7DB7280_00 +0000FFFFFFFFFFFF 577FFFFF_01 +FC00200000001FFE DC7FF7FF_01 +FFFFF16898822A24 D5697677_01 +00007FFFFFFFFFFF 56FFFFFF_01 +3FFF03FFFFFFFFFE 5E7FFC0F_01 +FFFFFF8FFE18C7BF D2E003CE_01 +00003FFFFFFFFFFF 567FFFFF_01 +FFFFFEFFFEFFFFFD D3800080_01 +00F03620C1266ED9 5B703620_01 +00001FFFFFFFFFFF 55FFFFFF_01 +BF7EFFFFFFFFFFFF DE810200_01 +FFFFFFFFFFFFFFD5 C22C0000_00 +00000FFFFFFFFFFF 557FFFFF_01 +FFFBFFFFF803FFFE D8800000_01 +0000000000068684 48D0D080_00 +000007FFFFFFFFFF 54FFFFFF_01 +DFFFFFE00000001E DE000000_01 +FFFFFFFFFFFFECF5 C5985800_00 +000003FFFFFFFFFF 547FFFFF_01 +FFFF00400000FFFF D77FBFFF_01 +0000000000000002 40000000_00 +000001FFFFFFFFFF 53FFFFFF_01 +FBFFFFFFFFFFBDFE DC800000_01 +0000000000000BC9 453C9000_00 +000000FFFFFFFFFF 537FFFFF_01 +807FFFFFFFFFDFFE DEFF0000_01 +FFC274E35A70CD76 DA762C72_01 +0000007FFFFFFFFF 52FFFFFF_01 +0FFFFFFFFEFFFFFD 5D7FFFFF_01 +FFFFFFFF00E73AFC CF7F18C5_01 +0000003FFFFFFFFF 527FFFFF_01 +FFC000000001000E DA7FFFFF_01 +FFFFFFFFFFFE15E9 C7F50B80_00 +0000001FFFFFFFFF 51FFFFFF_01 +0001FFFFFFFFF3FD 57FFFFFF_01 +0000000000000033 424C0000_00 +0000000FFFFFFFFF 517FFFFF_01 +000000001FFFBFFF 4DFFFDFF_01 +FFFFFFEE6B141E1B D18CA75F_01 +00000007FFFFFFFF 50FFFFFF_01 +FFFFFFFFF60007FF CD1FFF80_01 +00000001AB310BA6 4FD59885_01 +00000003FFFFFFFF 507FFFFF_01 +0003FFFFB7FFFFFF 587FFFED_01 +FFFFFFFFFFFFF195 C566B000_00 +00000001FFFFFFFF 4FFFFFFF_01 +FFFFFFFF8000000B CEFFFFFF_01 +00000019BA8D5559 51CDD46A_01 +00000000FFFFFFFF 4F7FFFFF_01 +FBFEFFFFFFFFFFF9 DC802000_01 +FFFFFFB6F062822D D2921F3A_01 +000000007FFFFFFF 4EFFFFFF_01 +0001000000000082 57800000_01 +01CEAD9E2FB104A4 5BE756CF_01 +000000003FFFFFFF 4E7FFFFF_01 +000003FFFFFFFF7C 547FFFFF_01 +FFFFFFFFFD681E78 CC25F862_00 +000000001FFFFFFF 4DFFFFFF_01 +00002000400001FF 56000100_01 +0000000000000018 41C00000_00 +000000000FFFFFFF 4D7FFFFF_01 +3FFF80000000003E 5E7FFE00_01 +FFFFFFFFFFFFFF95 C2D60000_00 +0000000007FFFFFF 4CFFFFFF_01 +010000BFFFFFFFFF 5B80005F_01 +0000001697087B19 51B4B843_01 +0000000003FFFFFF 4C7FFFFF_01 +FBFFFFFFFFEEFFFD DC800000_01 +0000000E64BDFC55 51664BDF_01 +0000000001FFFFFF 4BFFFFFF_01 +FC00000001FFFFFE DC7FFFFF_01 +FFFED156A62AB849 D79754AC_01 +0000000000FFFFFF 4B7FFFFF_00 +FFFFFFF83FEFFFFD D0F80200_01 +00015354EAE7C259 57A9AA75_01 +00000000007FFFFF 4AFFFFFE_00 +FFFFFFFFFFFFFF7F C3010000_00 +FFFFFFF0F4DF3C75 D170B20C_01 +00000000003FFFFF 4A7FFFFC_00 +FFFA000000001FFF D8BFFFFF_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000001FFFFF 49FFFFF8_00 +FFFFFFFFFF7FFE40 CB0001C0_00 +FFFFFFDB5433CB9B D212AF30_01 +00000000000FFFFF 497FFFF0_00 +FFFFFDFFDFFDFFFD D4000800_01 +FFFFFFFFFFDEAE1F CA054784_00 +000000000007FFFF 48FFFFE0_00 +FFFFFFFFF0080006 CD7F7FFF_01 +FFFFFFFE7735DEC7 CFC46510_01 +000000000003FFFF 487FFFC0_00 +00000001FBFFFFFF 4FFDFFFF_01 +000003757D8B12ED 545D5F62_01 +000000000001FFFF 47FFFF80_00 +FFFFFE07F7FFFFFF D3FC0400_01 +00000A654064E046 55265406_01 +000000000000FFFF 477FFF00_00 +08000000000017FF 5D000000_01 +FFFFFFFFFFFFFFE7 C1C80000_00 +0000000000007FFF 46FFFE00_00 +07FFFFFFFFFFFDF6 5CFFFFFF_01 +FFFFAD78B3D6C3B6 D6A50E98_01 +0000000000003FFF 467FFC00_00 +0000300004000000 56400010_00 +FFFFFFF70B77F34F D10F4880_01 +0000000000001FFF 45FFF800_00 +FFFFFF80006FFFFE D2FFFF20_01 +0000013EB4D67EC8 539F5A6B_01 +0000000000000FFF 457FF000_00 +BFFFDFFFFBFFFFFF DE800040_01 +0005CEAF34EA1DC7 58B9D5E6_01 +00000000000007FF 44FFE000_00 +00004800007FFFFD 56900000_01 +FFFFFFFFFFFFFFFB C0A00000_00 +00000000000003FF 447FC000_00 +0000000200001000 50000004_00 +00000000000360D0 48583400_00 +00000000000001FF 43FF8000_00 +01003FFFFFFFFFFC 5B801FFF_01 +00C000708FF1BA51 5B400070_01 +00000000000000FF 437F0000_00 +F802000003FFFFFF DCFFBFFF_01 +0F9E07DCC0BDC061 5D79E07D_01 +000000000000007F 42FE0000_00 +03FF0000000000FF 5C7FC000_01 +FFFFFFE1B9B2A079 D1F2326A_01 +000000000000003F 427C0000_00 +FFF80000000080FF D8FFFFFF_01 +00000000001EB5B4 49F5ADA0_00 +000000000000001F 41F80000_00 +000000000077FBFE 4AEFF7FC_00 +00000000005AC607 4AB58C0E_00 +000000000000000F 41700000_00 +FFFFFFFEF80000FF CF83FFFF_01 +000005C5B9D66984 54B8B73A_01 +0000000000000007 40E00000_00 +C001FFFFFFF00000 DE7FF800_01 +00001D06B372AA06 55E8359B_01 +0000000000000003 40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_rd.tv b/wally-pipelined/testbench/fp/i64_f64_rd.tv new file mode 100644 index 000000000..eaab9a1ee --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f64_rd.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 439FFFF7FFFFFFFD_01 +0000000032CC8B7A 41C96645BD000000_00 +0000000000000000 0000000000000000_00 +FFFFFFFFC0003FFE C1CFFFE001000000_00 +032C857F319EDE38 4389642BF98CF6F1_01 +0000000000000001 3FF0000000000000_00 +FFFFFBFFFFF8003E C29000001FFF0800_00 +00394C79B6D3007B 434CA63CDB69803D_01 +0000000000000002 4000000000000000_00 +FBFFFFF0000001FF C39000003FFFFFF9_01 +0000000001AE458D 417AE458D0000000_00 +0000000000000004 4010000000000000_00 +00040008000007FE 4310002000001FF8_00 +F9EB456140D88764 C39852EA7AFC9DE3_01 +0000000000000008 4020000000000000_00 +FFFFE400FFFFFFFE C2BBFF0000000200_00 +07DE834A248EDF36 439F7A0D28923B7C_01 +0000000000000010 4030000000000000_00 +00000003FF001FFF 420FF800FFF80000_00 +FFFFFFFFFFE385E2 C13C7A1E00000000_00 +0000000000000020 4040000000000000_00 +F0041FFFFFFFFFFF C3AFF7C000000001_01 +000000059EB1FD45 42167AC7F5140000_00 +0000000000000040 4050000000000000_00 +FFFFFFFFFFFCFFF9 C108003800000000_00 +FFFFFFFFFFFEDDFE C0F2202000000000_00 +0000000000000080 4060000000000000_00 +000000000003FF00 410FF80000000000_00 +00000000C89FF56B 41E913FEAD600000_00 +0000000000000100 4070000000000000_00 +000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEBF_01 +0000000000000200 4080000000000000_00 +FFFDF803FFFFFFFF C3003FE000000008_00 +FFFFFFFFFFF4766B C127132A00000000_00 +0000000000000400 4090000000000000_00 +0000080100000FFE 42A00200001FFC00_00 +000000000000000C 4028000000000000_00 +0000000000000800 40A0000000000000_00 +0048000000100000 4352000000040000_00 +FFE662A109109D0A C3399D5EF6EF62F6_00 +0000000000001000 40B0000000000000_00 +C000000037FFFFFE C3CFFFFFFFE40001_01 +FFFFFFFFFFFFFFE4 C03C000000000000_00 +0000000000002000 40C0000000000000_00 +F801000000100000 C39FFBFFFFFFC000_00 +FE114B79075F70EE C37EEB486F8A08F2_01 +0000000000004000 40D0000000000000_00 +100000000001003E 43B0000000000100_01 +00000000000003AC 408D600000000000_00 +0000000000008000 40E0000000000000_00 +200000FFFFFFF800 43C000007FFFFFFC_00 +00000044A3A3DBE5 425128E8F6F94000_00 +0000000000010000 40F0000000000000_00 +FFE0003EFFFFFFFF C33FFFC100000001_00 +FFFFFFFFFFFF1A91 C0ECADE000000000_00 +0000000000020000 4100000000000000_00 +FFFFF7C3FFFFFFFD C2A0780000000600_00 +0000000000003309 40C9848000000000_00 +0000000000040000 4110000000000000_00 +000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58 C065000000000000_00 +0000000000080000 4120000000000000_00 +FFFFFFDE01FFFFFE C240FF0000010000_00 +0000000000002980 40C4C00000000000_00 +0000000000100000 4130000000000000_00 +00000000FFF07FFF 41EFFE0FFFE00000_00 +000000000000005D 4057400000000000_00 +0000000000200000 4140000000000000_00 +000020FFDFFFFFFF 42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 +0000000000400000 4150000000000000_00 +E0000000003FFFDF C3BFFFFFFFFFC001_01 +FFFFFDE3C1DEC43C C280E1F109DE2000_00 +0000000000800000 4160000000000000_00 +FFFF00000BFFFFFD C2EFFFFE80000060_00 +000000000030FFBE 41487FDF00000000_00 +0000000001000000 4170000000000000_00 +FFFE000007FFEFFD C2FFFFFF80010030_00 +FFFFFFFFEFDEED86 C1B021127A000000_00 +0000000002000000 4180000000000000_00 +F3FFFFFFFFBFFFFE C3A8000000008001_01 +000000001DA3FF45 41BDA3FF45000000_00 +0000000004000000 4190000000000000_00 +FFFFFFFF00010007 C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54 C1F64E434AC00000_00 +0000000008000000 41A0000000000000_00 +00004000004001FE 42D0000010007F80_00 +F27DD19DE6563714 C3AB045CC4335392_01 +0000000010000000 41B0000000000000_00 +FFC00000004007FE C34FFFFFFFDFFC01_00 +000000000001A359 40FA359000000000_00 +0000000020000000 41C0000000000000_00 +0000000003C000FE 418E0007F0000000_00 +FFFFFFFFFE62EC20 C179D13E00000000_00 +0000000040000000 41D0000000000000_00 +000000003FFFFFFD 41CFFFFFFE800000_00 +000000000000285F 40C42F8000000000_00 +0000000080000000 41E0000000000000_00 +FFFFFFFFBFFFF00F C1D00003FC400000_00 +FFFFF836F99DBAA8 C29F241989156000_00 +0000000100000000 41F0000000000000_00 +00000020003FFEFE 4240001FFF7F0000_00 +0033466832042D47 4349A334190216A3_01 +0000000200000000 4200000000000000_00 +FFFFFFFFFFFFF887 C09DE40000000000_00 +00000000003829C8 414C14E400000000_00 +0000000400000000 4210000000000000_00 +00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 +0000000FB77C672B 422F6EF8CE560000_00 +0000000800000000 4220000000000000_00 +08003FFDFFFFFFFE 43A0007FFBFFFFFF_01 +0000000000001B78 40BB780000000000_00 +0000001000000000 4230000000000000_00 +FF7FFFFFFFEFDFFF C360000000020401_01 +0000000000000071 405C400000000000_00 +0000002000000000 4240000000000000_00 +000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86 C05E800000000000_00 +0000004000000000 4250000000000000_00 +0800000000040800 43A0000000000810_00 +FFF8A60D9E19F17E C31D67C987983A08_00 +0000008000000000 4260000000000000_00 +000077FFF0000000 42DDFFFC00000000_00 +FFFFFFFFF7506DBA C1A15F248C000000_00 +0000010000000000 4270000000000000_00 +FFFFFFFFFFFEFBF7 C0F0409000000000_00 +FFFFFFFFFEA42AC9 C175BD5370000000_00 +0000020000000000 4280000000000000_00 +0000107FFFFFDFFD 42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89 C33855C0D4253377_00 +0000040000000000 4290000000000000_00 +FFF8040000040000 C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +0000080000000000 42A0000000000000_00 +FFFF80000800001F C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9 C3004BF1099291B8_00 +0000100000000000 42B0000000000000_00 +FFFFFEFFFFE0007F C2700001FFF81000_00 +FFFFFFFFFFFFCFBE C0C8210000000000_00 +0000200000000000 42C0000000000000_00 +0000000901FFFFFD 422203FFFFFA0000_00 +FEC01FECA24DE1B0 C373FE0135DB21E5_00 +0000400000000000 42D0000000000000_00 +F7FFFFFFDFFF7FFF C3A0000000400101_01 +F858A66761669936 C39E9D66627A659C_01 +0000800000000000 42E0000000000000_00 +FFFEFF800000003E C2F007FFFFFFFC20_00 +F716EA43FAC45C97 C3A1D22B780A7747_01 +0001000000000000 42F0000000000000_00 +FFFFFFFFFFFFFFC6 C04D000000000000_00 +0024D70EC7661FD8 43426B8763B30FEC_00 +0002000000000000 4300000000000000_00 +C07FFFFFFFFFFFFE C3CFC00000000001_01 +FFD956DBD0AEE817 C343549217A88BF5_01 +0004000000000000 4310000000000000_00 +020003EFFFFFFFFE 4380001F7FFFFFFF_01 +FFFFFFFFFFFF4300 C0E7A00000000000_00 +0008000000000000 4320000000000000_00 +4000000004002000 43D0000000010008_00 +C12EDF40F41F6021 C3CF68905F85F050_01 +0010000000000000 4330000000000000_00 +FF9000000000001D C35BFFFFFFFFFFF9_01 +FFFFFFF83DE950F6 C21F085ABC280000_00 +0020000000000000 4340000000000000_00 +800003FFFFFC0000 C3DFFFFF00000100_00 +FE2B59CB3A604D69 C37D4A634C59FB2A_01 +0040000000000000 4350000000000000_00 +7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFEF_01 +000000A37C210862 42646F84210C4000_00 +0080000000000000 4360000000000000_00 +0002000002000002 4300000010000010_00 +FFFFB65CD8617789 C2D268C9E7A21DC0_00 +0100000000000000 4370000000000000_00 +00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D C0AFC60000000000_00 +0200000000000000 4380000000000000_00 +1000008000003FFF 43B000008000003F_01 +000000000D098D19 41AA131A32000000_00 +0400000000000000 4390000000000000_00 +03FFFFFFFFFFF5FF 438FFFFFFFFFFFAF_01 +000006B3BD2C7BEF 429ACEF4B1EFBC00_00 +0800000000000000 43A0000000000000_00 +00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 +1000000000000000 43B0000000000000_00 +001FFFC000000FFD 433FFFC000000FFD_00 +FFFFFFFFFFFFFF21 C06BE00000000000_00 +2000000000000000 43C0000000000000_00 +0000000041DFFFFF 41D077FFFFC00000_00 +FFFFFFFFFC648262 C18CDBECF0000000_00 +4000000000000000 43D0000000000000_00 +C0001FFFFFFFFFFB C3CFFFF000000001_01 +FFFFFF7353AC45D2 C261958A7745C000_00 +8000000000000000 C3E0000000000000_00 +FFFFFFFFFFE7EFFF C138100100000000_00 +0000000000A1202D 41642405A0000000_00 +C000000000000000 C3D0000000000000_00 +FFFFFFFFFFFF5F7F C0E4102000000000_00 +000000000040CA70 4150329C00000000_00 +E000000000000000 C3C0000000000000_00 +0000200201FFFFFE 42C00100FFFFFF00_00 +00000003B55D87D4 420DAAEC3EA00000_00 +F000000000000000 C3B0000000000000_00 +FF80000DFFFFFFFF C35FFFFC80000001_01 +000000010510FAEF 41F0510FAEF00000_00 +F800000000000000 C3A0000000000000_00 +0003FFF00000000F 430FFF8000000078_00 +000000000000724A 40DC928000000000_00 +FC00000000000000 C390000000000000_00 +FFFFFFDF80000002 C2403FFFFFFF0000_00 +0000000000000064 4059000000000000_00 +FE00000000000000 C380000000000000_00 +FEFFFFFFFFF800FE C370000000007FF1_01 +FFFFFFC2C6222702 C24E9CEEEC7F0000_00 +FF00000000000000 C370000000000000_00 +0000000408000002 4210200000080000_00 +000000E96DF1CB41 426D2DBE39682000_00 +FF80000000000000 C360000000000000_00 +007FFFFFFFFFF9FE 435FFFFFFFFFFE7F_01 +F727F174DEE7DC85 C3A1B01D16423047_01 +FFC0000000000000 C350000000000000_00 +8000000003FFFEFE C3DFFFFFFFFF0001_01 +FFFFFFFFFFF0BD5B C12E854A00000000_00 +FFE0000000000000 C340000000000000_00 +0BEFFFFFFFFFFFFF 43A7DFFFFFFFFFFF_01 +000000000002790C 4103C86000000000_00 +FFF0000000000000 C330000000000000_00 +FFFFFFFFFFEFFBFA C130040600000000_00 +000000169E75DF01 42369E75DF010000_00 +FFF8000000000000 C320000000000000_00 +00000007FEFFDFFF 421FFBFF7FFC0000_00 +000000000000000E 402C000000000000_00 +FFFC000000000000 C310000000000000_00 +0003FFFE0007FFFE 430FFFF0003FFFF0_00 +FFFFFFFFFFF28622 C12AF3BC00000000_00 +FFFE000000000000 C300000000000000_00 +FFFFFF7FFFFDF7FF C260000041002000_00 +00072F0EC496FE21 431CBC3B125BF884_00 +FFFF000000000000 C2F0000000000000_00 +DFBFFFFFFFFFFFFE C3C0200000000001_01 +0000000000FC1FCA 416F83F940000000_00 +FFFF800000000000 C2E0000000000000_00 +00000FFF800FFFFE 42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE C2E5CD636AC7A640_00 +FFFFC00000000000 C2D0000000000000_00 +00000002100007FD 420080003FE80000_00 +FFFFFFFFFFC2D8FE C14E938100000000_00 +FFFFE00000000000 C2C0000000000000_00 +000000000007FF6E 411FFDB800000000_00 +000000000001766E 40F766E000000000_00 +FFFFF00000000000 C2B0000000000000_00 +0040000400000002 4350000100000000_01 +0000000000007841 40DE104000000000_00 +FFFFF80000000000 C2A0000000000000_00 +3DFFFFFFFFFFFF7E 43CEFFFFFFFFFFFF_01 +FFFFFFE549E17E30 C23AB61E81D00000_00 +FFFFFC0000000000 C290000000000000_00 +FFFFFFFFFFFFFEE1 C071F00000000000_00 +FFFFFFFFFFFFFFE7 C039000000000000_00 +FFFFFE0000000000 C280000000000000_00 +000000000EFFFFDF 41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73 C061A00000000000_00 +FFFFFF0000000000 C270000000000000_00 +FD00000008000000 C387FFFFFFC00000_00 +000000000001DBB1 40FDBB1000000000_00 +FFFFFF8000000000 C260000000000000_00 +FFFFFFFFFFF8007F C11FFE0400000000_00 +FFFFFFFEFD10A515 C1F02EF5AEB00000_00 +FFFFFFC000000000 C250000000000000_00 +FFEFFFFFFFFFFFFE C330000000000002_00 +FAB02984F6283B6C C3953F59EC275F13_01 +FFFFFFE000000000 C240000000000000_00 +FFFFFFBC000001FE C250FFFFFF808000_00 +FEB087C6B9FE7FE0 C374F78394601802_00 +FFFFFFF000000000 C230000000000000_00 +FFF80001000007FE C31FFFFBFFFFE008_00 +00F2762EA6837956 436E4EC5D4D06F2A_01 +FFFFFFF800000000 C220000000000000_00 +FFF7E0FFFFFFFFFE C3203E0000000004_00 +00002E1175484626 42C708BAA4231300_00 +FFFFFFFC00000000 C210000000000000_00 +0000200020000FFE 42C000100007FF00_00 +000000000000068F 409A3C0000000000_00 +FFFFFFFE00000000 C200000000000000_00 +021FFFFFFFFBFFFF 4380FFFFFFFFDFFF_01 +FFFFFFFFFFFFFFF9 C01C000000000000_00 +FFFFFFFF00000000 C1F0000000000000_00 +FFFFFFD0000FFFFD C247FFF800018000_00 +000000BDF6658B83 4267BECCB1706000_00 +FFFFFFFF80000000 C1E0000000000000_00 +1000001FFDFFFFFF 43B000001FFDFFFF_01 +0000000000003B5B 40CDAD8000000000_00 +FFFFFFFFC0000000 C1D0000000000000_00 +FFFFFFBFFE0FFFFF C250007C00004000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +FFFFFFFFE0000000 C1C0000000000000_00 +FFFFFFFBF00007FF C2103FFFE0040000_00 +01E986274F48EAAD 437E986274F48EAA_01 +FFFFFFFFF0000000 C1B0000000000000_00 +1FFFFFFDFFFFFF7F 43BFFFFFFDFFFFFF_01 +FFFFFFFFFFFFCB5A C0CA530000000000_00 +FFFFFFFFF8000000 C1A0000000000000_00 +7FF000000000FFFF 43DFFC000000003F_01 +00000003C2717FC3 420E138BFE180000_00 +FFFFFFFFFC000000 C190000000000000_00 +FFFFFFE00008001F C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA C130542600000000_00 +FFFFFFFFFE000000 C180000000000000_00 +0200000000000002 4380000000000000_01 +FFFFFFFFF8FDA53F C19C096B04000000_00 +FFFFFFFFFF000000 C170000000000000_00 +F6000003FFFFFFFE C3A3FFFFF8000001_01 +FFFFFFFFFFFFFFD0 C048000000000000_00 +FFFFFFFFFF800000 C160000000000000_00 +FFFFFFFFFFBFFF7E C150002080000000_00 +00000000EE0FEA62 41EDC1FD4C400000_00 +FFFFFFFFFFC00000 C150000000000000_00 +0000007FFF9FFFFD 425FFFE7FFFF4000_00 +00000037F35EDC1D 424BF9AF6E0E8000_00 +FFFFFFFFFFE00000 C140000000000000_00 +FFFFFFF7FDFFFF7D C220040001060000_00 +00000000000001AD 407AD00000000000_00 +FFFFFFFFFFF00000 C130000000000000_00 +FFFFFF0000100020 C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A 43C3F8B3FDE3FE2F_01 +FFFFFFFFFFF80000 C120000000000000_00 +003FFFFFFFFC0001 434FFFFFFFFE0000_01 +000E48F9F4EBD30E 432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000 C110000000000000_00 +DFFFFFFFFFFBFFFE C3C0000000000201_01 +FC91C23EE8C9424F C38B71EE08B9B5EE_01 +FFFFFFFFFFFE0000 C100000000000000_00 +F7DFFBFFFFFFFFFE C3A0400800000001_01 +000000002CAE080C 41C6570406000000_00 +FFFFFFFFFFFF0000 C0F0000000000000_00 +FFFFC00010000020 C2CFFFF7FFFFF000_00 +04D921F917B20E40 43936487E45EC839_00 +FFFFFFFFFFFF8000 C0E0000000000000_00 +F8000FFFFFFFFFFD C39FFFC000000001_01 +FFF17C566BC7D811 C32D075328704FDE_00 +FFFFFFFFFFFFC000 C0D0000000000000_00 +00000000000000FE 406FC00000000000_00 +FFF82AC14930D386 C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000 C0C0000000000000_00 +00000000000003FC 408FE00000000000_00 +000E62EC60E119FC 432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000 C0B0000000000000_00 +FFFFEFF7FF7FFFFE C2B0080080000200_00 +0E2B1ECF210EEDC5 43AC563D9E421DDB_01 +FFFFFFFFFFFFF800 C0A0000000000000_00 +00000000007FFF1F 415FFFC7C0000000_00 +FFFFFE534F5676F7 C27ACB0A98909000_00 +FFFFFFFFFFFFFC00 C090000000000000_00 +0000001004FFFFFD 423004FFFFFD0000_00 +0000035C939669F1 428AE49CB34F8800_00 +FFFFFFFFFFFFFE00 C080000000000000_00 +1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFD_01 +FFFFFFFFFFFFFF91 C05BC00000000000_00 +FFFFFFFFFFFFFF00 C070000000000000_00 +01FFFFFFFBFFEFFE 437FFFFFFFBFFEFF_01 +000000000000016E 4076E00000000000_00 +FFFFFFFFFFFFFF80 C060000000000000_00 +FFF7FFFFFFFFF7FD C320000000001006_00 +FFFFF8E2BCFAC553 C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0 C050000000000000_00 +FFFFFBFFFFFE0FFE C290000007C00800_00 +00000001A4E704BF 41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0 C040000000000000_00 +1400007FFFFFFFFD 43B400007FFFFFFF_01 +FFFFFFFC93B187B4 C20B6273C2600000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +40000000007FFFFD 43D0000000001FFF_01 +000000000067D468 4159F51A00000000_00 +FFFFFFFFFFFFFFF8 C020000000000000_00 +007FFEFFFFFBFFFE 435FFFBFFFFEFFFF_01 +FFFFFFE26CEC79F8 C23D931386080000_00 +FFFFFFFFFFFFFFFC C010000000000000_00 +00FFFFFF000000FF 436FFFFFE000001F_01 +FFFFFFFFE0D3983A C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE C000000000000000_00 +00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF BFF0000000000000_00 +000008000000027E 42A000000004FC00_00 +000000000000F4E8 40EE9D0000000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFF83FFDF C15F000840000000_00 +00000E11407887B2 42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +04000003FFFFFFF6 439000000FFFFFFF_01 +0000000000000513 40944C0000000000_00 +FFFFFFFFFFFFFFF7 C022000000000000_00 +BFFC00000000003E C3D0010000000000_01 +00000008D7BBB75B 4221AF776EB60000_00 +FFFFFFFFFFFFFFEF C031000000000000_00 +000FFFFBFFFC0000 432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23 C14952EE80000000_00 +FFFFFFFFFFFFFFDF C040800000000000_00 +FFBFDFFFBFFFFFFF C350080010000001_01 +000000000000007F 405FC00000000000_00 +FFFFFFFFFFFFFFBF C050400000000000_00 +00000007FF800003 421FFE00000C0000_00 +000000000002BB02 4105D81000000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEE7FF C0F1801000000000_00 +00264B2B9BAD0DA2 43432595CDD686D1_00 +FFFFFFFFFFFFFEFF C070100000000000_00 +0000000000100803 4130080300000000_00 +FF9B1DCB9F857D5E C359388D181EA0A9_01 +FFFFFFFFFFFFFDFF C080080000000000_00 +FFFFFFBFFFFFEFEE C250000004048000_00 +F6FD7542899C1C6F C3A205157AECC7C8_01 +FFFFFFFFFFFFFBFF C090040000000000_00 +FF800000004001FF C35FFFFFFFEFFF81_01 +0000000002BE4932 4185F24990000000_00 +FFFFFFFFFFFFF7FF C0A0020000000000_00 +00001004000FFFFE 42B004000FFFFE00_00 +FFFFFF9DAA0123E0 C258957FB7080000_00 +FFFFFFFFFFFFEFFF C0B0010000000000_00 +00000001FDFFFDFE 41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF C0C0008000000000_00 +FE0FE00000000000 C37F020000000000_00 +0779ED944A4E2779 439DE7B65129389D_01 +FFFFFFFFFFFFBFFF C0D0004000000000_00 +FBFFFE0400000000 C3900007F0000000_00 +0000010127E03666 4270127E03666000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +FFFFF0200000FFFE C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEFFFF C0F0001000000000_00 +FFEFFE0000080000 C33001FFFFF80000_00 +FFFFFFFFFD3354EA C1866558B0000000_00 +FFFFFFFFFFFDFFFF C100000800000000_00 +003FF0000003FFFE 434FF8000001FFFF_00 +0000006375B23F7B 4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF C110000400000000_00 +000407FFFFFFFFF6 43101FFFFFFFFFD8_00 +0000000092117F38 41E2422FE7000000_00 +FFFFFFFFFFF7FFFF C120000200000000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +00000000000008BE 40A17C0000000000_00 +FFFFFFFFFFEFFFFF C130000100000000_00 +004000020FFFFFFF 4350000083FFFFFF_01 +FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF C140000080000000_00 +00FFFFFFFFFFFFFD 436FFFFFFFFFFFFF_01 +00000023C2C6F284 4241E16379420000_00 +FFFFFFFFFFBFFFFF C150000040000000_00 +FFFDDFFFFFFFFFFD C301000000000018_00 +00000000746356C4 41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF C160000020000000_00 +010000000000BFFF 4370000000000BFF_01 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFEFFFFFF C170000010000000_00 +FFFFBF7FFBFFFFFE C2D0200100000080_00 +00000006386CE889 4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF C180000008000000_00 +F00000F7FFFFFFFF C3AFFFFE10000001_01 +FFFDFC53090C46A4 C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +0000000000800047 41600008E0000000_00 +FFFFFFFFD693872E C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF C1A0000002000000_00 +000000007FBFFBFF 41DFEFFEFFC00000_00 +00000026A7845E35 424353C22F1A8000_00 +FFFFFFFFEFFFFFFF C1B0000001000000_00 +FFFFFFDFFFFFFBFD C240000002018000_00 +000000001433D14C 41B433D14C000000_00 +FFFFFFFFDFFFFFFF C1C0000000800000_00 +0001FFFFFFE0000E 42FFFFFFFE0000E0_00 +F0F23E8068D3D84A C3AE1B82FF2E5850_01 +FFFFFFFFBFFFFFFF C1D0000000400000_00 +F7FFBFFFFFFFBFFF C3A0008000000081_01 +FFFFBD29B7459087 C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF C1E0000000200000_00 +FFFFFFF8FFFFBFFF C21C000100040000_00 +FFFFFFFFFFEDDC06 C13223FA00000000_00 +FFFFFFFEFFFFFFFF C1F0000000100000_00 +FFFFFFF80001FFFF C21FFFF800040000_00 +0000000000002FF9 40C7FC8000000000_00 +FFFFFFFDFFFFFFFF C200000000080000_00 +004000040000FFFF 4350000100003FFF_01 +FFFFFFFFFFFFFFF1 C02E000000000000_00 +FFFFFFFBFFFFFFFF C210000000040000_00 +C0000000007FFFFA C3CFFFFFFFFFC001_01 +FFFFFFFFFE053E2B C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF C220000000020000_00 +7FFE000007FFFFFF 43DFFF800001FFFF_01 +000000000000000D 402A000000000000_00 +FFFFFFEFFFFFFFFF C230000000010000_00 +F80000000001007E C39FFFFFFFFFFBFF_01 +FFFFED48424AD9D6 C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF C240000000008000_00 +FFFFFE0001FEFFFF C27FFFE010001000_00 +000000000000013B 4073B00000000000_00 +FFFFFFBFFFFFFFFF C250000000004000_00 +0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 +4A16BD4128090C83 43D285AF504A0243_01 +FFFFFF7FFFFFFFFF C260000000002000_00 +00FFF7FFFF7FFFFE 436FFEFFFFEFFFFF_01 +0000000000000006 4018000000000000_00 +FFFFFEFFFFFFFFFF C270000000001000_00 +FBFFFFBFFFBFFFFF C390000100010001_01 +00000000000001BA 407BA00000000000_00 +FFFFFDFFFFFFFFFF C280000000000800_00 +0000000040000082 41D0000020800000_00 +FF07A2BF5B689F89 C36F0BA81492EC0F_01 +FFFFFBFFFFFFFFFF C290000000000400_00 +0000001FF8000008 423FF80000080000_00 +F87CAA7DE672DE8B C39E0D5608663486_01 +FFFFF7FFFFFFFFFF C2A0000000000200_00 +07FFF80000000002 439FFFE000000000_01 +0000000010A1E5B8 41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF C2B0000000000100_00 +F7FFFFE00007FFFF C3A000003FFFF001_01 +FFFFFFFFFFF6ADFC C122A40800000000_00 +FFFFDFFFFFFFFFFF C2C0000000000080_00 +FFFFFF03FFFFFFC0 C26F800000080000_00 +EA579475948F0032 C3B5A86B8A6B7100_01 +FFFFBFFFFFFFFFFF C2D0000000000040_00 +FC00000000003FF6 C38FFFFFFFFFFE01_01 +002E677AC313BF60 434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF C2E0000000000020_00 +02000007FF7FFFFF 438000003FFBFFFF_01 +0000000E999639F1 422D332C73E20000_00 +FFFEFFFFFFFFFFFF C2F0000000000010_00 +FFFF83FFFFFFFFBE C2DF000000001080_00 +000000000001537D 40F537D000000000_00 +FFFDFFFFFFFFFFFF C300000000000008_00 +EFFFFFC00000003D C3B0000040000000_01 +FFFFFFF21FEDFD35 C22BC02405960000_00 +FFFBFFFFFFFFFFFF C310000000000004_00 +FFFFFFF0000007FE C22FFFFFF0040000_00 +FFFFFFFFFFDE0839 C140FBE380000000_00 +FFF7FFFFFFFFFFFF C320000000000002_00 +0000007FFFE000FF 425FFFF8003FC000_00 +FFFFFFFF79F30F48 C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF C330000000000001_00 +FFFFFC13FFFFFFFD C28F600000001800_00 +0000000000001B85 40BB850000000000_00 +FFDFFFFFFFFFFFFF C340000000000001_01 +000008000007FFFE 42A000000FFFFC00_00 +12DB4409E5AE87E6 43B2DB4409E5AE87_01 +FFBFFFFFFFFFFFFF C350000000000001_01 +FFFFFFFFFFF7BFEE C120802400000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FF7FFFFFFFFFFFFF C360000000000001_01 +000000001040FFFE 41B040FFFE000000_00 +00000909A09C13D3 42A213413827A600_00 +FEFFFFFFFFFFFFFF C370000000000001_01 +FFFFFF01FFFFFF7F C26FC00000102000_00 +FFFFFF72E7D2575D C261A305B5146000_00 +FDFFFFFFFFFFFFFF C380000000000001_01 +FFFFFFFFFFFEFFDB C0F0025000000000_00 +0000000000000017 4037000000000000_00 +FBFFFFFFFFFFFFFF C390000000000001_01 +100000001FFFFFF6 43B00000001FFFFF_01 +000000114B12EF51 42314B12EF510000_00 +F7FFFFFFFFFFFFFF C3A0000000000001_01 +0407FFFFFFFFFEFF 43901FFFFFFFFFFB_01 +FFFFFF769F3A5C2C C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF C3B0000000000001_01 +FFFFFFFDF7FFFFFD C200400000180000_00 +FFFFFFFFFFFFFFF2 C02C000000000000_00 +DFFFFFFFFFFFFFFF C3C0000000000001_01 +FFFFFFFFFE0007FF C17FFF8010000000_00 +000000000000001E 403E000000000000_00 +BFFFFFFFFFFFFFFF C3D0000000000001_01 +FFF800000009FFFF C31FFFFFFFD80004_00 +0000000000007AA4 40DEA90000000000_00 +7FFFFFFFFFFFFFFF 43DFFFFFFFFFFFFF_01 +4080000000FFFFFF 43D0200000003FFF_01 +000000000DE7601D 41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF 43CFFFFFFFFFFFFF_01 +FFCFFFFFFFBFFFFE C348000000200001_00 +FFFFFFFFFFFFFFCA C04B000000000000_00 +1FFFFFFFFFFFFFFF 43BFFFFFFFFFFFFF_01 +000080400000003F 42E00800000007E0_00 +00000000001F75A5 413F75A500000000_00 +0FFFFFFFFFFFFFFF 43AFFFFFFFFFFFFF_01 +FFFFFFEFFFFFCFFE C230000030020000_00 +FFFFFEE775887420 C27188A778BE0000_00 +07FFFFFFFFFFFFFF 439FFFFFFFFFFFFF_01 +00000000000801FE 412003FC00000000_00 +0000000000213FF1 41409FF880000000_00 +03FFFFFFFFFFFFFF 438FFFFFFFFFFFFF_01 +07FEFFFFFFFFFFEE 439FFBFFFFFFFFFF_01 +0000000000000004 4010000000000000_00 +01FFFFFFFFFFFFFF 437FFFFFFFFFFFFF_01 +0000000820000003 4220400000060000_00 +FFFFFFF9AD105214 C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF 436FFFFFFFFFFFFF_01 +FFFFF00FFFFFFFBE C2AFE00000008400_00 +FFFFFFFFFFCC48E7 C149DB8C80000000_00 +007FFFFFFFFFFFFF 435FFFFFFFFFFFFF_01 +00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB C16E8B26A0000000_00 +003FFFFFFFFFFFFF 434FFFFFFFFFFFFF_01 +FFFFFF7FBFFFFFBF C260080000082000_00 +FFFFFFFFFFF24425 C12B77B600000000_00 +001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 +200000001FFBFFFF 43C00000000FFDFF_01 +FFFFFF4E7115EC53 C26631DD4275A000_00 +000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF C29FF00000010400_00 +FFFFFC2E539ADCFE C28E8D6329181000_00 +0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +00000055084732F3 42554211CCBCC000_00 +0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00 C3D0002000000001_01 +FFFFFFFFFFFF8543 C0DEAF4000000000_00 +0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 +0000001FFBFFE000 423FFBFFE0000000_00 +FFFFFFFFFFFE491B C0FB6E5000000000_00 +0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 +FC00200000001FFE C38FFEFFFFFFFF01_01 +FFFFF16898822A24 C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE 43CFFF81FFFFFFFF_01 +FFFFFF8FFE18C7BF C25C0079CE104000_00 +00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD C270001000003000_00 +00F03620C1266ED9 436E06C41824CDDB_01 +00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF C3D0204000000001_01 +FFFFFFFFFFFFFFD5 C045800000000000_00 +00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE C31000001FF00008_00 +0000000000068684 411A1A1000000000_00 +000007FFFFFFFFFF 429FFFFFFFFFFC00_00 +DFFFFFE00000001E C3C0000010000000_01 +FFFFFFFFFFFFECF5 C0B30B0000000000_00 +000003FFFFFFFFFF 428FFFFFFFFFF800_00 +FFFF00400000FFFF C2EFF7FFFFE00020_00 +0000000000000002 4000000000000000_00 +000001FFFFFFFFFF 427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE C390000000000109_01 +0000000000000BC9 40A7920000000000_00 +000000FFFFFFFFFF 426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE C3DFE00000000009_01 +FFC274E35A70CD76 C34EC58E52C79945_00 +0000007FFFFFFFFF 425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD 43AFFFFFFFFDFFFF_01 +FFFFFFFF00E73AFC C1EFE318A0800000_00 +0000003FFFFFFFFF 424FFFFFFFFF8000_00 +FFC000000001000E C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9 C0FEA17000000000_00 +0000001FFFFFFFFF 423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 +0000000000000033 4049800000000000_00 +0000000FFFFFFFFF 422FFFFFFFFE0000_00 +000000001FFFBFFF 41BFFFBFFF000000_00 +FFFFFFEE6B141E1B C23194EBE1E50000_00 +00000007FFFFFFFF 421FFFFFFFFC0000_00 +FFFFFFFFF60007FF C1A3FFF002000000_00 +00000001AB310BA6 41FAB310BA600000_00 +00000003FFFFFFFF 420FFFFFFFF80000_00 +0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195 C0ACD60000000000_00 +00000001FFFFFFFF 41FFFFFFFFF00000_00 +FFFFFFFF8000000B C1DFFFFFFD400000_00 +00000019BA8D5559 4239BA8D55590000_00 +00000000FFFFFFFF 41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9 C390040000000001_01 +FFFFFFB6F062822D C25243E75F74C000_00 +000000007FFFFFFF 41DFFFFFFFC00000_00 +0001000000000082 42F0000000000820_00 +01CEAD9E2FB104A4 437CEAD9E2FB104A_01 +000000003FFFFFFF 41CFFFFFFF800000_00 +000003FFFFFFFF7C 428FFFFFFFFBE000_00 +FFFFFFFFFD681E78 C184BF0C40000000_00 +000000001FFFFFFF 41BFFFFFFF000000_00 +00002000400001FF 42C000200000FF80_00 +0000000000000018 4038000000000000_00 +000000000FFFFFFF 41AFFFFFFE000000_00 +3FFF80000000003E 43CFFFC000000000_01 +FFFFFFFFFFFFFF95 C05AC00000000000_00 +0000000007FFFFFF 419FFFFFFC000000_00 +010000BFFFFFFFFF 4370000BFFFFFFFF_01 +0000001697087B19 423697087B190000_00 +0000000003FFFFFF 418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD C390000000004401_01 +0000000E64BDFC55 422CC97BF8AA0000_00 +0000000001FFFFFF 417FFFFFF0000000_00 +FC00000001FFFFFE C38FFFFFFFF00001_01 +FFFED156A62AB849 C2F2EA959D547B70_00 +0000000000FFFFFF 416FFFFFE0000000_00 +FFFFFFF83FEFFFFD C21F0040000C0000_00 +00015354EAE7C259 42F5354EAE7C2590_00 +00000000007FFFFF 415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFF0F4DF3C75 C22E164187160000_00 +00000000003FFFFF 414FFFFF80000000_00 +FFFA000000001FFF C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000001FFFFF 413FFFFF00000000_00 +FFFFFFFFFF7FFE40 C160003800000000_00 +FFFFFFDB5433CB9B C24255E61A328000_00 +00000000000FFFFF 412FFFFE00000000_00 +FFFFFDFFDFFDFFFD C280010010001800_00 +FFFFFFFFFFDEAE1F C140A8F080000000_00 +000000000007FFFF 411FFFFC00000000_00 +FFFFFFFFF0080006 C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7 C1F88CA213900000_00 +000000000003FFFF 410FFFF800000000_00 +00000001FBFFFFFF 41FFBFFFFFF00000_00 +000003757D8B12ED 428BABEC58976800_00 +000000000001FFFF 40FFFFF000000000_00 +FFFFFE07F7FFFFFF C27F808000001000_00 +00000A654064E046 42A4CA80C9C08C00_00 +000000000000FFFF 40EFFFE000000000_00 +08000000000017FF 43A000000000002F_01 +FFFFFFFFFFFFFFE7 C039000000000000_00 +0000000000007FFF 40DFFFC000000000_00 +07FFFFFFFFFFFDF6 439FFFFFFFFFFFF7_01 +FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 +0000000000003FFF 40CFFF8000000000_00 +0000300004000000 42C8000200000000_00 +FFFFFFF70B77F34F C221E91019620000_00 +0000000000001FFF 40BFFF0000000000_00 +FFFFFF80006FFFFE C25FFFE400008000_00 +0000013EB4D67EC8 4273EB4D67EC8000_00 +0000000000000FFF 40AFFE0000000000_00 +BFFFDFFFFBFFFFFF C3D0000800010001_01 +0005CEAF34EA1DC7 43173ABCD3A8771C_00 +00000000000007FF 409FFC0000000000_00 +00004800007FFFFD 42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000000003FF 408FF80000000000_00 +0000000200001000 4200000080000000_00 +00000000000360D0 410B068000000000_00 +00000000000001FF 407FF00000000000_00 +01003FFFFFFFFFFC 437003FFFFFFFFFF_01 +00C000708FF1BA51 4368000E11FE374A_01 +00000000000000FF 406FE00000000000_00 +F802000003FFFFFF C39FF7FFFFF00001_01 +0F9E07DCC0BDC061 43AF3C0FB9817B80_01 +000000000000007F 405FC00000000000_00 +03FF0000000000FF 438FF80000000007_01 +FFFFFFE1B9B2A079 C23E464D5F870000_00 +000000000000003F 404F800000000000_00 +FFF80000000080FF C31FFFFFFFFDFC04_00 +00000000001EB5B4 413EB5B400000000_00 +000000000000001F 403F000000000000_00 +000000000077FBFE 415DFEFF80000000_00 +00000000005AC607 4156B181C0000000_00 +000000000000000F 402E000000000000_00 +FFFFFFFEF80000FF C1F07FFFF0100000_00 +000005C5B9D66984 429716E759A61000_00 +0000000000000007 401C000000000000_00 +C001FFFFFFF00000 C3CFFF0000000800_00 +00001D06B372AA06 42BD06B372AA0600_00 +0000000000000003 4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_rne.tv b/wally-pipelined/testbench/fp/i64_f64_rne.tv new file mode 100644 index 000000000..ed6b0a3ac --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f64_rne.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 439FFFF7FFFFFFFE_01 +0000000032CC8B7A 41C96645BD000000_00 +0000000000000000 0000000000000000_00 +FFFFFFFFC0003FFE C1CFFFE001000000_00 +032C857F319EDE38 4389642BF98CF6F2_01 +0000000000000001 3FF0000000000000_00 +FFFFFBFFFFF8003E C29000001FFF0800_00 +00394C79B6D3007B 434CA63CDB69803E_01 +0000000000000002 4000000000000000_00 +FBFFFFF0000001FF C39000003FFFFFF8_01 +0000000001AE458D 417AE458D0000000_00 +0000000000000004 4010000000000000_00 +00040008000007FE 4310002000001FF8_00 +F9EB456140D88764 C39852EA7AFC9DE2_01 +0000000000000008 4020000000000000_00 +FFFFE400FFFFFFFE C2BBFF0000000200_00 +07DE834A248EDF36 439F7A0D28923B7D_01 +0000000000000010 4030000000000000_00 +00000003FF001FFF 420FF800FFF80000_00 +FFFFFFFFFFE385E2 C13C7A1E00000000_00 +0000000000000020 4040000000000000_00 +F0041FFFFFFFFFFF C3AFF7C000000000_01 +000000059EB1FD45 42167AC7F5140000_00 +0000000000000040 4050000000000000_00 +FFFFFFFFFFFCFFF9 C108003800000000_00 +FFFFFFFFFFFEDDFE C0F2202000000000_00 +0000000000000080 4060000000000000_00 +000000000003FF00 410FF80000000000_00 +00000000C89FF56B 41E913FEAD600000_00 +0000000000000100 4070000000000000_00 +000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEC0_01 +0000000000000200 4080000000000000_00 +FFFDF803FFFFFFFF C3003FE000000008_00 +FFFFFFFFFFF4766B C127132A00000000_00 +0000000000000400 4090000000000000_00 +0000080100000FFE 42A00200001FFC00_00 +000000000000000C 4028000000000000_00 +0000000000000800 40A0000000000000_00 +0048000000100000 4352000000040000_00 +FFE662A109109D0A C3399D5EF6EF62F6_00 +0000000000001000 40B0000000000000_00 +C000000037FFFFFE C3CFFFFFFFE40000_01 +FFFFFFFFFFFFFFE4 C03C000000000000_00 +0000000000002000 40C0000000000000_00 +F801000000100000 C39FFBFFFFFFC000_00 +FE114B79075F70EE C37EEB486F8A08F1_01 +0000000000004000 40D0000000000000_00 +100000000001003E 43B0000000000100_01 +00000000000003AC 408D600000000000_00 +0000000000008000 40E0000000000000_00 +200000FFFFFFF800 43C000007FFFFFFC_00 +00000044A3A3DBE5 425128E8F6F94000_00 +0000000000010000 40F0000000000000_00 +FFE0003EFFFFFFFF C33FFFC100000001_00 +FFFFFFFFFFFF1A91 C0ECADE000000000_00 +0000000000020000 4100000000000000_00 +FFFFF7C3FFFFFFFD C2A0780000000600_00 +0000000000003309 40C9848000000000_00 +0000000000040000 4110000000000000_00 +000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58 C065000000000000_00 +0000000000080000 4120000000000000_00 +FFFFFFDE01FFFFFE C240FF0000010000_00 +0000000000002980 40C4C00000000000_00 +0000000000100000 4130000000000000_00 +00000000FFF07FFF 41EFFE0FFFE00000_00 +000000000000005D 4057400000000000_00 +0000000000200000 4140000000000000_00 +000020FFDFFFFFFF 42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 +0000000000400000 4150000000000000_00 +E0000000003FFFDF C3BFFFFFFFFFC000_01 +FFFFFDE3C1DEC43C C280E1F109DE2000_00 +0000000000800000 4160000000000000_00 +FFFF00000BFFFFFD C2EFFFFE80000060_00 +000000000030FFBE 41487FDF00000000_00 +0000000001000000 4170000000000000_00 +FFFE000007FFEFFD C2FFFFFF80010030_00 +FFFFFFFFEFDEED86 C1B021127A000000_00 +0000000002000000 4180000000000000_00 +F3FFFFFFFFBFFFFE C3A8000000008000_01 +000000001DA3FF45 41BDA3FF45000000_00 +0000000004000000 4190000000000000_00 +FFFFFFFF00010007 C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54 C1F64E434AC00000_00 +0000000008000000 41A0000000000000_00 +00004000004001FE 42D0000010007F80_00 +F27DD19DE6563714 C3AB045CC4335392_01 +0000000010000000 41B0000000000000_00 +FFC00000004007FE C34FFFFFFFDFFC01_00 +000000000001A359 40FA359000000000_00 +0000000020000000 41C0000000000000_00 +0000000003C000FE 418E0007F0000000_00 +FFFFFFFFFE62EC20 C179D13E00000000_00 +0000000040000000 41D0000000000000_00 +000000003FFFFFFD 41CFFFFFFE800000_00 +000000000000285F 40C42F8000000000_00 +0000000080000000 41E0000000000000_00 +FFFFFFFFBFFFF00F C1D00003FC400000_00 +FFFFF836F99DBAA8 C29F241989156000_00 +0000000100000000 41F0000000000000_00 +00000020003FFEFE 4240001FFF7F0000_00 +0033466832042D47 4349A334190216A4_01 +0000000200000000 4200000000000000_00 +FFFFFFFFFFFFF887 C09DE40000000000_00 +00000000003829C8 414C14E400000000_00 +0000000400000000 4210000000000000_00 +00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 +0000000FB77C672B 422F6EF8CE560000_00 +0000000800000000 4220000000000000_00 +08003FFDFFFFFFFE 43A0007FFC000000_01 +0000000000001B78 40BB780000000000_00 +0000001000000000 4230000000000000_00 +FF7FFFFFFFEFDFFF C360000000020400_01 +0000000000000071 405C400000000000_00 +0000002000000000 4240000000000000_00 +000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86 C05E800000000000_00 +0000004000000000 4250000000000000_00 +0800000000040800 43A0000000000810_00 +FFF8A60D9E19F17E C31D67C987983A08_00 +0000008000000000 4260000000000000_00 +000077FFF0000000 42DDFFFC00000000_00 +FFFFFFFFF7506DBA C1A15F248C000000_00 +0000010000000000 4270000000000000_00 +FFFFFFFFFFFEFBF7 C0F0409000000000_00 +FFFFFFFFFEA42AC9 C175BD5370000000_00 +0000020000000000 4280000000000000_00 +0000107FFFFFDFFD 42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89 C33855C0D4253377_00 +0000040000000000 4290000000000000_00 +FFF8040000040000 C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +0000080000000000 42A0000000000000_00 +FFFF80000800001F C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9 C3004BF1099291B8_00 +0000100000000000 42B0000000000000_00 +FFFFFEFFFFE0007F C2700001FFF81000_00 +FFFFFFFFFFFFCFBE C0C8210000000000_00 +0000200000000000 42C0000000000000_00 +0000000901FFFFFD 422203FFFFFA0000_00 +FEC01FECA24DE1B0 C373FE0135DB21E5_00 +0000400000000000 42D0000000000000_00 +F7FFFFFFDFFF7FFF C3A0000000400100_01 +F858A66761669936 C39E9D66627A659B_01 +0000800000000000 42E0000000000000_00 +FFFEFF800000003E C2F007FFFFFFFC20_00 +F716EA43FAC45C97 C3A1D22B780A7747_01 +0001000000000000 42F0000000000000_00 +FFFFFFFFFFFFFFC6 C04D000000000000_00 +0024D70EC7661FD8 43426B8763B30FEC_00 +0002000000000000 4300000000000000_00 +C07FFFFFFFFFFFFE C3CFC00000000000_01 +FFD956DBD0AEE817 C343549217A88BF4_01 +0004000000000000 4310000000000000_00 +020003EFFFFFFFFE 4380001F80000000_01 +FFFFFFFFFFFF4300 C0E7A00000000000_00 +0008000000000000 4320000000000000_00 +4000000004002000 43D0000000010008_00 +C12EDF40F41F6021 C3CF68905F85F050_01 +0010000000000000 4330000000000000_00 +FF9000000000001D C35BFFFFFFFFFFF9_01 +FFFFFFF83DE950F6 C21F085ABC280000_00 +0020000000000000 4340000000000000_00 +800003FFFFFC0000 C3DFFFFF00000100_00 +FE2B59CB3A604D69 C37D4A634C59FB29_01 +0040000000000000 4350000000000000_00 +7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFF0_01 +000000A37C210862 42646F84210C4000_00 +0080000000000000 4360000000000000_00 +0002000002000002 4300000010000010_00 +FFFFB65CD8617789 C2D268C9E7A21DC0_00 +0100000000000000 4370000000000000_00 +00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D C0AFC60000000000_00 +0200000000000000 4380000000000000_00 +1000008000003FFF 43B0000080000040_01 +000000000D098D19 41AA131A32000000_00 +0400000000000000 4390000000000000_00 +03FFFFFFFFFFF5FF 438FFFFFFFFFFFB0_01 +000006B3BD2C7BEF 429ACEF4B1EFBC00_00 +0800000000000000 43A0000000000000_00 +00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 +1000000000000000 43B0000000000000_00 +001FFFC000000FFD 433FFFC000000FFD_00 +FFFFFFFFFFFFFF21 C06BE00000000000_00 +2000000000000000 43C0000000000000_00 +0000000041DFFFFF 41D077FFFFC00000_00 +FFFFFFFFFC648262 C18CDBECF0000000_00 +4000000000000000 43D0000000000000_00 +C0001FFFFFFFFFFB C3CFFFF000000000_01 +FFFFFF7353AC45D2 C261958A7745C000_00 +8000000000000000 C3E0000000000000_00 +FFFFFFFFFFE7EFFF C138100100000000_00 +0000000000A1202D 41642405A0000000_00 +C000000000000000 C3D0000000000000_00 +FFFFFFFFFFFF5F7F C0E4102000000000_00 +000000000040CA70 4150329C00000000_00 +E000000000000000 C3C0000000000000_00 +0000200201FFFFFE 42C00100FFFFFF00_00 +00000003B55D87D4 420DAAEC3EA00000_00 +F000000000000000 C3B0000000000000_00 +FF80000DFFFFFFFF C35FFFFC80000000_01 +000000010510FAEF 41F0510FAEF00000_00 +F800000000000000 C3A0000000000000_00 +0003FFF00000000F 430FFF8000000078_00 +000000000000724A 40DC928000000000_00 +FC00000000000000 C390000000000000_00 +FFFFFFDF80000002 C2403FFFFFFF0000_00 +0000000000000064 4059000000000000_00 +FE00000000000000 C380000000000000_00 +FEFFFFFFFFF800FE C370000000007FF0_01 +FFFFFFC2C6222702 C24E9CEEEC7F0000_00 +FF00000000000000 C370000000000000_00 +0000000408000002 4210200000080000_00 +000000E96DF1CB41 426D2DBE39682000_00 +FF80000000000000 C360000000000000_00 +007FFFFFFFFFF9FE 435FFFFFFFFFFE80_01 +F727F174DEE7DC85 C3A1B01D16423047_01 +FFC0000000000000 C350000000000000_00 +8000000003FFFEFE C3DFFFFFFFFF0000_01 +FFFFFFFFFFF0BD5B C12E854A00000000_00 +FFE0000000000000 C340000000000000_00 +0BEFFFFFFFFFFFFF 43A7E00000000000_01 +000000000002790C 4103C86000000000_00 +FFF0000000000000 C330000000000000_00 +FFFFFFFFFFEFFBFA C130040600000000_00 +000000169E75DF01 42369E75DF010000_00 +FFF8000000000000 C320000000000000_00 +00000007FEFFDFFF 421FFBFF7FFC0000_00 +000000000000000E 402C000000000000_00 +FFFC000000000000 C310000000000000_00 +0003FFFE0007FFFE 430FFFF0003FFFF0_00 +FFFFFFFFFFF28622 C12AF3BC00000000_00 +FFFE000000000000 C300000000000000_00 +FFFFFF7FFFFDF7FF C260000041002000_00 +00072F0EC496FE21 431CBC3B125BF884_00 +FFFF000000000000 C2F0000000000000_00 +DFBFFFFFFFFFFFFE C3C0200000000000_01 +0000000000FC1FCA 416F83F940000000_00 +FFFF800000000000 C2E0000000000000_00 +00000FFF800FFFFE 42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE C2E5CD636AC7A640_00 +FFFFC00000000000 C2D0000000000000_00 +00000002100007FD 420080003FE80000_00 +FFFFFFFFFFC2D8FE C14E938100000000_00 +FFFFE00000000000 C2C0000000000000_00 +000000000007FF6E 411FFDB800000000_00 +000000000001766E 40F766E000000000_00 +FFFFF00000000000 C2B0000000000000_00 +0040000400000002 4350000100000000_01 +0000000000007841 40DE104000000000_00 +FFFFF80000000000 C2A0000000000000_00 +3DFFFFFFFFFFFF7E 43CF000000000000_01 +FFFFFFE549E17E30 C23AB61E81D00000_00 +FFFFFC0000000000 C290000000000000_00 +FFFFFFFFFFFFFEE1 C071F00000000000_00 +FFFFFFFFFFFFFFE7 C039000000000000_00 +FFFFFE0000000000 C280000000000000_00 +000000000EFFFFDF 41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73 C061A00000000000_00 +FFFFFF0000000000 C270000000000000_00 +FD00000008000000 C387FFFFFFC00000_00 +000000000001DBB1 40FDBB1000000000_00 +FFFFFF8000000000 C260000000000000_00 +FFFFFFFFFFF8007F C11FFE0400000000_00 +FFFFFFFEFD10A515 C1F02EF5AEB00000_00 +FFFFFFC000000000 C250000000000000_00 +FFEFFFFFFFFFFFFE C330000000000002_00 +FAB02984F6283B6C C3953F59EC275F12_01 +FFFFFFE000000000 C240000000000000_00 +FFFFFFBC000001FE C250FFFFFF808000_00 +FEB087C6B9FE7FE0 C374F78394601802_00 +FFFFFFF000000000 C230000000000000_00 +FFF80001000007FE C31FFFFBFFFFE008_00 +00F2762EA6837956 436E4EC5D4D06F2B_01 +FFFFFFF800000000 C220000000000000_00 +FFF7E0FFFFFFFFFE C3203E0000000004_00 +00002E1175484626 42C708BAA4231300_00 +FFFFFFFC00000000 C210000000000000_00 +0000200020000FFE 42C000100007FF00_00 +000000000000068F 409A3C0000000000_00 +FFFFFFFE00000000 C200000000000000_00 +021FFFFFFFFBFFFF 4380FFFFFFFFE000_01 +FFFFFFFFFFFFFFF9 C01C000000000000_00 +FFFFFFFF00000000 C1F0000000000000_00 +FFFFFFD0000FFFFD C247FFF800018000_00 +000000BDF6658B83 4267BECCB1706000_00 +FFFFFFFF80000000 C1E0000000000000_00 +1000001FFDFFFFFF 43B000001FFE0000_01 +0000000000003B5B 40CDAD8000000000_00 +FFFFFFFFC0000000 C1D0000000000000_00 +FFFFFFBFFE0FFFFF C250007C00004000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +FFFFFFFFE0000000 C1C0000000000000_00 +FFFFFFFBF00007FF C2103FFFE0040000_00 +01E986274F48EAAD 437E986274F48EAB_01 +FFFFFFFFF0000000 C1B0000000000000_00 +1FFFFFFDFFFFFF7F 43BFFFFFFDFFFFFF_01 +FFFFFFFFFFFFCB5A C0CA530000000000_00 +FFFFFFFFF8000000 C1A0000000000000_00 +7FF000000000FFFF 43DFFC0000000040_01 +00000003C2717FC3 420E138BFE180000_00 +FFFFFFFFFC000000 C190000000000000_00 +FFFFFFE00008001F C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA C130542600000000_00 +FFFFFFFFFE000000 C180000000000000_00 +0200000000000002 4380000000000000_01 +FFFFFFFFF8FDA53F C19C096B04000000_00 +FFFFFFFFFF000000 C170000000000000_00 +F6000003FFFFFFFE C3A3FFFFF8000000_01 +FFFFFFFFFFFFFFD0 C048000000000000_00 +FFFFFFFFFF800000 C160000000000000_00 +FFFFFFFFFFBFFF7E C150002080000000_00 +00000000EE0FEA62 41EDC1FD4C400000_00 +FFFFFFFFFFC00000 C150000000000000_00 +0000007FFF9FFFFD 425FFFE7FFFF4000_00 +00000037F35EDC1D 424BF9AF6E0E8000_00 +FFFFFFFFFFE00000 C140000000000000_00 +FFFFFFF7FDFFFF7D C220040001060000_00 +00000000000001AD 407AD00000000000_00 +FFFFFFFFFFF00000 C130000000000000_00 +FFFFFF0000100020 C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A 43C3F8B3FDE3FE30_01 +FFFFFFFFFFF80000 C120000000000000_00 +003FFFFFFFFC0001 434FFFFFFFFE0000_01 +000E48F9F4EBD30E 432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000 C110000000000000_00 +DFFFFFFFFFFBFFFE C3C0000000000200_01 +FC91C23EE8C9424F C38B71EE08B9B5EE_01 +FFFFFFFFFFFE0000 C100000000000000_00 +F7DFFBFFFFFFFFFE C3A0400800000000_01 +000000002CAE080C 41C6570406000000_00 +FFFFFFFFFFFF0000 C0F0000000000000_00 +FFFFC00010000020 C2CFFFF7FFFFF000_00 +04D921F917B20E40 43936487E45EC839_00 +FFFFFFFFFFFF8000 C0E0000000000000_00 +F8000FFFFFFFFFFD C39FFFC000000000_01 +FFF17C566BC7D811 C32D075328704FDE_00 +FFFFFFFFFFFFC000 C0D0000000000000_00 +00000000000000FE 406FC00000000000_00 +FFF82AC14930D386 C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000 C0C0000000000000_00 +00000000000003FC 408FE00000000000_00 +000E62EC60E119FC 432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000 C0B0000000000000_00 +FFFFEFF7FF7FFFFE C2B0080080000200_00 +0E2B1ECF210EEDC5 43AC563D9E421DDC_01 +FFFFFFFFFFFFF800 C0A0000000000000_00 +00000000007FFF1F 415FFFC7C0000000_00 +FFFFFE534F5676F7 C27ACB0A98909000_00 +FFFFFFFFFFFFFC00 C090000000000000_00 +0000001004FFFFFD 423004FFFFFD0000_00 +0000035C939669F1 428AE49CB34F8800_00 +FFFFFFFFFFFFFE00 C080000000000000_00 +1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFE_01 +FFFFFFFFFFFFFF91 C05BC00000000000_00 +FFFFFFFFFFFFFF00 C070000000000000_00 +01FFFFFFFBFFEFFE 437FFFFFFFBFFF00_01 +000000000000016E 4076E00000000000_00 +FFFFFFFFFFFFFF80 C060000000000000_00 +FFF7FFFFFFFFF7FD C320000000001006_00 +FFFFF8E2BCFAC553 C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0 C050000000000000_00 +FFFFFBFFFFFE0FFE C290000007C00800_00 +00000001A4E704BF 41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0 C040000000000000_00 +1400007FFFFFFFFD 43B4000080000000_01 +FFFFFFFC93B187B4 C20B6273C2600000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +40000000007FFFFD 43D0000000002000_01 +000000000067D468 4159F51A00000000_00 +FFFFFFFFFFFFFFF8 C020000000000000_00 +007FFEFFFFFBFFFE 435FFFBFFFFF0000_01 +FFFFFFE26CEC79F8 C23D931386080000_00 +FFFFFFFFFFFFFFFC C010000000000000_00 +00FFFFFF000000FF 436FFFFFE0000020_01 +FFFFFFFFE0D3983A C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE C000000000000000_00 +00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF BFF0000000000000_00 +000008000000027E 42A000000004FC00_00 +000000000000F4E8 40EE9D0000000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFF83FFDF C15F000840000000_00 +00000E11407887B2 42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +04000003FFFFFFF6 4390000010000000_01 +0000000000000513 40944C0000000000_00 +FFFFFFFFFFFFFFF7 C022000000000000_00 +BFFC00000000003E C3D0010000000000_01 +00000008D7BBB75B 4221AF776EB60000_00 +FFFFFFFFFFFFFFEF C031000000000000_00 +000FFFFBFFFC0000 432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23 C14952EE80000000_00 +FFFFFFFFFFFFFFDF C040800000000000_00 +FFBFDFFFBFFFFFFF C350080010000000_01 +000000000000007F 405FC00000000000_00 +FFFFFFFFFFFFFFBF C050400000000000_00 +00000007FF800003 421FFE00000C0000_00 +000000000002BB02 4105D81000000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEE7FF C0F1801000000000_00 +00264B2B9BAD0DA2 43432595CDD686D1_00 +FFFFFFFFFFFFFEFF C070100000000000_00 +0000000000100803 4130080300000000_00 +FF9B1DCB9F857D5E C359388D181EA0A8_01 +FFFFFFFFFFFFFDFF C080080000000000_00 +FFFFFFBFFFFFEFEE C250000004048000_00 +F6FD7542899C1C6F C3A205157AECC7C7_01 +FFFFFFFFFFFFFBFF C090040000000000_00 +FF800000004001FF C35FFFFFFFEFFF80_01 +0000000002BE4932 4185F24990000000_00 +FFFFFFFFFFFFF7FF C0A0020000000000_00 +00001004000FFFFE 42B004000FFFFE00_00 +FFFFFF9DAA0123E0 C258957FB7080000_00 +FFFFFFFFFFFFEFFF C0B0010000000000_00 +00000001FDFFFDFE 41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF C0C0008000000000_00 +FE0FE00000000000 C37F020000000000_00 +0779ED944A4E2779 439DE7B65129389E_01 +FFFFFFFFFFFFBFFF C0D0004000000000_00 +FBFFFE0400000000 C3900007F0000000_00 +0000010127E03666 4270127E03666000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +FFFFF0200000FFFE C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEFFFF C0F0001000000000_00 +FFEFFE0000080000 C33001FFFFF80000_00 +FFFFFFFFFD3354EA C1866558B0000000_00 +FFFFFFFFFFFDFFFF C100000800000000_00 +003FF0000003FFFE 434FF8000001FFFF_00 +0000006375B23F7B 4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF C110000400000000_00 +000407FFFFFFFFF6 43101FFFFFFFFFD8_00 +0000000092117F38 41E2422FE7000000_00 +FFFFFFFFFFF7FFFF C120000200000000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +00000000000008BE 40A17C0000000000_00 +FFFFFFFFFFEFFFFF C130000100000000_00 +004000020FFFFFFF 4350000084000000_01 +FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF C140000080000000_00 +00FFFFFFFFFFFFFD 4370000000000000_01 +00000023C2C6F284 4241E16379420000_00 +FFFFFFFFFFBFFFFF C150000040000000_00 +FFFDDFFFFFFFFFFD C301000000000018_00 +00000000746356C4 41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF C160000020000000_00 +010000000000BFFF 4370000000000C00_01 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFEFFFFFF C170000010000000_00 +FFFFBF7FFBFFFFFE C2D0200100000080_00 +00000006386CE889 4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF C180000008000000_00 +F00000F7FFFFFFFF C3AFFFFE10000000_01 +FFFDFC53090C46A4 C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +0000000000800047 41600008E0000000_00 +FFFFFFFFD693872E C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF C1A0000002000000_00 +000000007FBFFBFF 41DFEFFEFFC00000_00 +00000026A7845E35 424353C22F1A8000_00 +FFFFFFFFEFFFFFFF C1B0000001000000_00 +FFFFFFDFFFFFFBFD C240000002018000_00 +000000001433D14C 41B433D14C000000_00 +FFFFFFFFDFFFFFFF C1C0000000800000_00 +0001FFFFFFE0000E 42FFFFFFFE0000E0_00 +F0F23E8068D3D84A C3AE1B82FF2E584F_01 +FFFFFFFFBFFFFFFF C1D0000000400000_00 +F7FFBFFFFFFFBFFF C3A0008000000080_01 +FFFFBD29B7459087 C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF C1E0000000200000_00 +FFFFFFF8FFFFBFFF C21C000100040000_00 +FFFFFFFFFFEDDC06 C13223FA00000000_00 +FFFFFFFEFFFFFFFF C1F0000000100000_00 +FFFFFFF80001FFFF C21FFFF800040000_00 +0000000000002FF9 40C7FC8000000000_00 +FFFFFFFDFFFFFFFF C200000000080000_00 +004000040000FFFF 4350000100004000_01 +FFFFFFFFFFFFFFF1 C02E000000000000_00 +FFFFFFFBFFFFFFFF C210000000040000_00 +C0000000007FFFFA C3CFFFFFFFFFC000_01 +FFFFFFFFFE053E2B C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF C220000000020000_00 +7FFE000007FFFFFF 43DFFF8000020000_01 +000000000000000D 402A000000000000_00 +FFFFFFEFFFFFFFFF C230000000010000_00 +F80000000001007E C39FFFFFFFFFFBFE_01 +FFFFED48424AD9D6 C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF C240000000008000_00 +FFFFFE0001FEFFFF C27FFFE010001000_00 +000000000000013B 4073B00000000000_00 +FFFFFFBFFFFFFFFF C250000000004000_00 +0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 +4A16BD4128090C83 43D285AF504A0243_01 +FFFFFF7FFFFFFFFF C260000000002000_00 +00FFF7FFFF7FFFFE 436FFEFFFFF00000_01 +0000000000000006 4018000000000000_00 +FFFFFEFFFFFFFFFF C270000000001000_00 +FBFFFFBFFFBFFFFF C390000100010000_01 +00000000000001BA 407BA00000000000_00 +FFFFFDFFFFFFFFFF C280000000000800_00 +0000000040000082 41D0000020800000_00 +FF07A2BF5B689F89 C36F0BA81492EC0F_01 +FFFFFBFFFFFFFFFF C290000000000400_00 +0000001FF8000008 423FF80000080000_00 +F87CAA7DE672DE8B C39E0D5608663486_01 +FFFFF7FFFFFFFFFF C2A0000000000200_00 +07FFF80000000002 439FFFE000000000_01 +0000000010A1E5B8 41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF C2B0000000000100_00 +F7FFFFE00007FFFF C3A000003FFFF000_01 +FFFFFFFFFFF6ADFC C122A40800000000_00 +FFFFDFFFFFFFFFFF C2C0000000000080_00 +FFFFFF03FFFFFFC0 C26F800000080000_00 +EA579475948F0032 C3B5A86B8A6B7100_01 +FFFFBFFFFFFFFFFF C2D0000000000040_00 +FC00000000003FF6 C38FFFFFFFFFFE00_01 +002E677AC313BF60 434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF C2E0000000000020_00 +02000007FF7FFFFF 438000003FFC0000_01 +0000000E999639F1 422D332C73E20000_00 +FFFEFFFFFFFFFFFF C2F0000000000010_00 +FFFF83FFFFFFFFBE C2DF000000001080_00 +000000000001537D 40F537D000000000_00 +FFFDFFFFFFFFFFFF C300000000000008_00 +EFFFFFC00000003D C3B0000040000000_01 +FFFFFFF21FEDFD35 C22BC02405960000_00 +FFFBFFFFFFFFFFFF C310000000000004_00 +FFFFFFF0000007FE C22FFFFFF0040000_00 +FFFFFFFFFFDE0839 C140FBE380000000_00 +FFF7FFFFFFFFFFFF C320000000000002_00 +0000007FFFE000FF 425FFFF8003FC000_00 +FFFFFFFF79F30F48 C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF C330000000000001_00 +FFFFFC13FFFFFFFD C28F600000001800_00 +0000000000001B85 40BB850000000000_00 +FFDFFFFFFFFFFFFF C340000000000000_01 +000008000007FFFE 42A000000FFFFC00_00 +12DB4409E5AE87E6 43B2DB4409E5AE88_01 +FFBFFFFFFFFFFFFF C350000000000000_01 +FFFFFFFFFFF7BFEE C120802400000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FF7FFFFFFFFFFFFF C360000000000000_01 +000000001040FFFE 41B040FFFE000000_00 +00000909A09C13D3 42A213413827A600_00 +FEFFFFFFFFFFFFFF C370000000000000_01 +FFFFFF01FFFFFF7F C26FC00000102000_00 +FFFFFF72E7D2575D C261A305B5146000_00 +FDFFFFFFFFFFFFFF C380000000000000_01 +FFFFFFFFFFFEFFDB C0F0025000000000_00 +0000000000000017 4037000000000000_00 +FBFFFFFFFFFFFFFF C390000000000000_01 +100000001FFFFFF6 43B0000000200000_01 +000000114B12EF51 42314B12EF510000_00 +F7FFFFFFFFFFFFFF C3A0000000000000_01 +0407FFFFFFFFFEFF 43901FFFFFFFFFFC_01 +FFFFFF769F3A5C2C C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF C3B0000000000000_01 +FFFFFFFDF7FFFFFD C200400000180000_00 +FFFFFFFFFFFFFFF2 C02C000000000000_00 +DFFFFFFFFFFFFFFF C3C0000000000000_01 +FFFFFFFFFE0007FF C17FFF8010000000_00 +000000000000001E 403E000000000000_00 +BFFFFFFFFFFFFFFF C3D0000000000000_01 +FFF800000009FFFF C31FFFFFFFD80004_00 +0000000000007AA4 40DEA90000000000_00 +7FFFFFFFFFFFFFFF 43E0000000000000_01 +4080000000FFFFFF 43D0200000004000_01 +000000000DE7601D 41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF 43D0000000000000_01 +FFCFFFFFFFBFFFFE C348000000200001_00 +FFFFFFFFFFFFFFCA C04B000000000000_00 +1FFFFFFFFFFFFFFF 43C0000000000000_01 +000080400000003F 42E00800000007E0_00 +00000000001F75A5 413F75A500000000_00 +0FFFFFFFFFFFFFFF 43B0000000000000_01 +FFFFFFEFFFFFCFFE C230000030020000_00 +FFFFFEE775887420 C27188A778BE0000_00 +07FFFFFFFFFFFFFF 43A0000000000000_01 +00000000000801FE 412003FC00000000_00 +0000000000213FF1 41409FF880000000_00 +03FFFFFFFFFFFFFF 4390000000000000_01 +07FEFFFFFFFFFFEE 439FFC0000000000_01 +0000000000000004 4010000000000000_00 +01FFFFFFFFFFFFFF 4380000000000000_01 +0000000820000003 4220400000060000_00 +FFFFFFF9AD105214 C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF 4370000000000000_01 +FFFFF00FFFFFFFBE C2AFE00000008400_00 +FFFFFFFFFFCC48E7 C149DB8C80000000_00 +007FFFFFFFFFFFFF 4360000000000000_01 +00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB C16E8B26A0000000_00 +003FFFFFFFFFFFFF 4350000000000000_01 +FFFFFF7FBFFFFFBF C260080000082000_00 +FFFFFFFFFFF24425 C12B77B600000000_00 +001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 +200000001FFBFFFF 43C00000000FFE00_01 +FFFFFF4E7115EC53 C26631DD4275A000_00 +000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF C29FF00000010400_00 +FFFFFC2E539ADCFE C28E8D6329181000_00 +0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +00000055084732F3 42554211CCBCC000_00 +0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00 C3D0002000000000_01 +FFFFFFFFFFFF8543 C0DEAF4000000000_00 +0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 +0000001FFBFFE000 423FFBFFE0000000_00 +FFFFFFFFFFFE491B C0FB6E5000000000_00 +0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 +FC00200000001FFE C38FFEFFFFFFFF00_01 +FFFFF16898822A24 C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE 43CFFF8200000000_01 +FFFFFF8FFE18C7BF C25C0079CE104000_00 +00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD C270001000003000_00 +00F03620C1266ED9 436E06C41824CDDB_01 +00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF C3D0204000000000_01 +FFFFFFFFFFFFFFD5 C045800000000000_00 +00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE C31000001FF00008_00 +0000000000068684 411A1A1000000000_00 +000007FFFFFFFFFF 429FFFFFFFFFFC00_00 +DFFFFFE00000001E C3C0000010000000_01 +FFFFFFFFFFFFECF5 C0B30B0000000000_00 +000003FFFFFFFFFF 428FFFFFFFFFF800_00 +FFFF00400000FFFF C2EFF7FFFFE00020_00 +0000000000000002 4000000000000000_00 +000001FFFFFFFFFF 427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE C390000000000108_01 +0000000000000BC9 40A7920000000000_00 +000000FFFFFFFFFF 426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE C3DFE00000000008_01 +FFC274E35A70CD76 C34EC58E52C79945_00 +0000007FFFFFFFFF 425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD 43AFFFFFFFFE0000_01 +FFFFFFFF00E73AFC C1EFE318A0800000_00 +0000003FFFFFFFFF 424FFFFFFFFF8000_00 +FFC000000001000E C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9 C0FEA17000000000_00 +0000001FFFFFFFFF 423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 +0000000000000033 4049800000000000_00 +0000000FFFFFFFFF 422FFFFFFFFE0000_00 +000000001FFFBFFF 41BFFFBFFF000000_00 +FFFFFFEE6B141E1B C23194EBE1E50000_00 +00000007FFFFFFFF 421FFFFFFFFC0000_00 +FFFFFFFFF60007FF C1A3FFF002000000_00 +00000001AB310BA6 41FAB310BA600000_00 +00000003FFFFFFFF 420FFFFFFFF80000_00 +0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195 C0ACD60000000000_00 +00000001FFFFFFFF 41FFFFFFFFF00000_00 +FFFFFFFF8000000B C1DFFFFFFD400000_00 +00000019BA8D5559 4239BA8D55590000_00 +00000000FFFFFFFF 41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9 C390040000000000_01 +FFFFFFB6F062822D C25243E75F74C000_00 +000000007FFFFFFF 41DFFFFFFFC00000_00 +0001000000000082 42F0000000000820_00 +01CEAD9E2FB104A4 437CEAD9E2FB104A_01 +000000003FFFFFFF 41CFFFFFFF800000_00 +000003FFFFFFFF7C 428FFFFFFFFBE000_00 +FFFFFFFFFD681E78 C184BF0C40000000_00 +000000001FFFFFFF 41BFFFFFFF000000_00 +00002000400001FF 42C000200000FF80_00 +0000000000000018 4038000000000000_00 +000000000FFFFFFF 41AFFFFFFE000000_00 +3FFF80000000003E 43CFFFC000000000_01 +FFFFFFFFFFFFFF95 C05AC00000000000_00 +0000000007FFFFFF 419FFFFFFC000000_00 +010000BFFFFFFFFF 4370000C00000000_01 +0000001697087B19 423697087B190000_00 +0000000003FFFFFF 418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD C390000000004400_01 +0000000E64BDFC55 422CC97BF8AA0000_00 +0000000001FFFFFF 417FFFFFF0000000_00 +FC00000001FFFFFE C38FFFFFFFF00000_01 +FFFED156A62AB849 C2F2EA959D547B70_00 +0000000000FFFFFF 416FFFFFE0000000_00 +FFFFFFF83FEFFFFD C21F0040000C0000_00 +00015354EAE7C259 42F5354EAE7C2590_00 +00000000007FFFFF 415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFF0F4DF3C75 C22E164187160000_00 +00000000003FFFFF 414FFFFF80000000_00 +FFFA000000001FFF C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000001FFFFF 413FFFFF00000000_00 +FFFFFFFFFF7FFE40 C160003800000000_00 +FFFFFFDB5433CB9B C24255E61A328000_00 +00000000000FFFFF 412FFFFE00000000_00 +FFFFFDFFDFFDFFFD C280010010001800_00 +FFFFFFFFFFDEAE1F C140A8F080000000_00 +000000000007FFFF 411FFFFC00000000_00 +FFFFFFFFF0080006 C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7 C1F88CA213900000_00 +000000000003FFFF 410FFFF800000000_00 +00000001FBFFFFFF 41FFBFFFFFF00000_00 +000003757D8B12ED 428BABEC58976800_00 +000000000001FFFF 40FFFFF000000000_00 +FFFFFE07F7FFFFFF C27F808000001000_00 +00000A654064E046 42A4CA80C9C08C00_00 +000000000000FFFF 40EFFFE000000000_00 +08000000000017FF 43A0000000000030_01 +FFFFFFFFFFFFFFE7 C039000000000000_00 +0000000000007FFF 40DFFFC000000000_00 +07FFFFFFFFFFFDF6 439FFFFFFFFFFFF8_01 +FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 +0000000000003FFF 40CFFF8000000000_00 +0000300004000000 42C8000200000000_00 +FFFFFFF70B77F34F C221E91019620000_00 +0000000000001FFF 40BFFF0000000000_00 +FFFFFF80006FFFFE C25FFFE400008000_00 +0000013EB4D67EC8 4273EB4D67EC8000_00 +0000000000000FFF 40AFFE0000000000_00 +BFFFDFFFFBFFFFFF C3D0000800010000_01 +0005CEAF34EA1DC7 43173ABCD3A8771C_00 +00000000000007FF 409FFC0000000000_00 +00004800007FFFFD 42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000000003FF 408FF80000000000_00 +0000000200001000 4200000080000000_00 +00000000000360D0 410B068000000000_00 +00000000000001FF 407FF00000000000_00 +01003FFFFFFFFFFC 4370040000000000_01 +00C000708FF1BA51 4368000E11FE374A_01 +00000000000000FF 406FE00000000000_00 +F802000003FFFFFF C39FF7FFFFF00000_01 +0F9E07DCC0BDC061 43AF3C0FB9817B81_01 +000000000000007F 405FC00000000000_00 +03FF0000000000FF 438FF80000000008_01 +FFFFFFE1B9B2A079 C23E464D5F870000_00 +000000000000003F 404F800000000000_00 +FFF80000000080FF C31FFFFFFFFDFC04_00 +00000000001EB5B4 413EB5B400000000_00 +000000000000001F 403F000000000000_00 +000000000077FBFE 415DFEFF80000000_00 +00000000005AC607 4156B181C0000000_00 +000000000000000F 402E000000000000_00 +FFFFFFFEF80000FF C1F07FFFF0100000_00 +000005C5B9D66984 429716E759A61000_00 +0000000000000007 401C000000000000_00 +C001FFFFFFF00000 C3CFFF0000000800_00 +00001D06B372AA06 42BD06B372AA0600_00 +0000000000000003 4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_ru.tv b/wally-pipelined/testbench/fp/i64_f64_ru.tv new file mode 100644 index 000000000..eca72d40b --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f64_ru.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 439FFFF7FFFFFFFE_01 +0000000032CC8B7A 41C96645BD000000_00 +0000000000000000 0000000000000000_00 +FFFFFFFFC0003FFE C1CFFFE001000000_00 +032C857F319EDE38 4389642BF98CF6F2_01 +0000000000000001 3FF0000000000000_00 +FFFFFBFFFFF8003E C29000001FFF0800_00 +00394C79B6D3007B 434CA63CDB69803E_01 +0000000000000002 4000000000000000_00 +FBFFFFF0000001FF C39000003FFFFFF8_01 +0000000001AE458D 417AE458D0000000_00 +0000000000000004 4010000000000000_00 +00040008000007FE 4310002000001FF8_00 +F9EB456140D88764 C39852EA7AFC9DE2_01 +0000000000000008 4020000000000000_00 +FFFFE400FFFFFFFE C2BBFF0000000200_00 +07DE834A248EDF36 439F7A0D28923B7D_01 +0000000000000010 4030000000000000_00 +00000003FF001FFF 420FF800FFF80000_00 +FFFFFFFFFFE385E2 C13C7A1E00000000_00 +0000000000000020 4040000000000000_00 +F0041FFFFFFFFFFF C3AFF7C000000000_01 +000000059EB1FD45 42167AC7F5140000_00 +0000000000000040 4050000000000000_00 +FFFFFFFFFFFCFFF9 C108003800000000_00 +FFFFFFFFFFFEDDFE C0F2202000000000_00 +0000000000000080 4060000000000000_00 +000000000003FF00 410FF80000000000_00 +00000000C89FF56B 41E913FEAD600000_00 +0000000000000100 4070000000000000_00 +000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEC0_01 +0000000000000200 4080000000000000_00 +FFFDF803FFFFFFFF C3003FE000000008_00 +FFFFFFFFFFF4766B C127132A00000000_00 +0000000000000400 4090000000000000_00 +0000080100000FFE 42A00200001FFC00_00 +000000000000000C 4028000000000000_00 +0000000000000800 40A0000000000000_00 +0048000000100000 4352000000040000_00 +FFE662A109109D0A C3399D5EF6EF62F6_00 +0000000000001000 40B0000000000000_00 +C000000037FFFFFE C3CFFFFFFFE40000_01 +FFFFFFFFFFFFFFE4 C03C000000000000_00 +0000000000002000 40C0000000000000_00 +F801000000100000 C39FFBFFFFFFC000_00 +FE114B79075F70EE C37EEB486F8A08F1_01 +0000000000004000 40D0000000000000_00 +100000000001003E 43B0000000000101_01 +00000000000003AC 408D600000000000_00 +0000000000008000 40E0000000000000_00 +200000FFFFFFF800 43C000007FFFFFFC_00 +00000044A3A3DBE5 425128E8F6F94000_00 +0000000000010000 40F0000000000000_00 +FFE0003EFFFFFFFF C33FFFC100000001_00 +FFFFFFFFFFFF1A91 C0ECADE000000000_00 +0000000000020000 4100000000000000_00 +FFFFF7C3FFFFFFFD C2A0780000000600_00 +0000000000003309 40C9848000000000_00 +0000000000040000 4110000000000000_00 +000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58 C065000000000000_00 +0000000000080000 4120000000000000_00 +FFFFFFDE01FFFFFE C240FF0000010000_00 +0000000000002980 40C4C00000000000_00 +0000000000100000 4130000000000000_00 +00000000FFF07FFF 41EFFE0FFFE00000_00 +000000000000005D 4057400000000000_00 +0000000000200000 4140000000000000_00 +000020FFDFFFFFFF 42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 +0000000000400000 4150000000000000_00 +E0000000003FFFDF C3BFFFFFFFFFC000_01 +FFFFFDE3C1DEC43C C280E1F109DE2000_00 +0000000000800000 4160000000000000_00 +FFFF00000BFFFFFD C2EFFFFE80000060_00 +000000000030FFBE 41487FDF00000000_00 +0000000001000000 4170000000000000_00 +FFFE000007FFEFFD C2FFFFFF80010030_00 +FFFFFFFFEFDEED86 C1B021127A000000_00 +0000000002000000 4180000000000000_00 +F3FFFFFFFFBFFFFE C3A8000000008000_01 +000000001DA3FF45 41BDA3FF45000000_00 +0000000004000000 4190000000000000_00 +FFFFFFFF00010007 C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54 C1F64E434AC00000_00 +0000000008000000 41A0000000000000_00 +00004000004001FE 42D0000010007F80_00 +F27DD19DE6563714 C3AB045CC4335391_01 +0000000010000000 41B0000000000000_00 +FFC00000004007FE C34FFFFFFFDFFC01_00 +000000000001A359 40FA359000000000_00 +0000000020000000 41C0000000000000_00 +0000000003C000FE 418E0007F0000000_00 +FFFFFFFFFE62EC20 C179D13E00000000_00 +0000000040000000 41D0000000000000_00 +000000003FFFFFFD 41CFFFFFFE800000_00 +000000000000285F 40C42F8000000000_00 +0000000080000000 41E0000000000000_00 +FFFFFFFFBFFFF00F C1D00003FC400000_00 +FFFFF836F99DBAA8 C29F241989156000_00 +0000000100000000 41F0000000000000_00 +00000020003FFEFE 4240001FFF7F0000_00 +0033466832042D47 4349A334190216A4_01 +0000000200000000 4200000000000000_00 +FFFFFFFFFFFFF887 C09DE40000000000_00 +00000000003829C8 414C14E400000000_00 +0000000400000000 4210000000000000_00 +00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 +0000000FB77C672B 422F6EF8CE560000_00 +0000000800000000 4220000000000000_00 +08003FFDFFFFFFFE 43A0007FFC000000_01 +0000000000001B78 40BB780000000000_00 +0000001000000000 4230000000000000_00 +FF7FFFFFFFEFDFFF C360000000020400_01 +0000000000000071 405C400000000000_00 +0000002000000000 4240000000000000_00 +000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86 C05E800000000000_00 +0000004000000000 4250000000000000_00 +0800000000040800 43A0000000000810_00 +FFF8A60D9E19F17E C31D67C987983A08_00 +0000008000000000 4260000000000000_00 +000077FFF0000000 42DDFFFC00000000_00 +FFFFFFFFF7506DBA C1A15F248C000000_00 +0000010000000000 4270000000000000_00 +FFFFFFFFFFFEFBF7 C0F0409000000000_00 +FFFFFFFFFEA42AC9 C175BD5370000000_00 +0000020000000000 4280000000000000_00 +0000107FFFFFDFFD 42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89 C33855C0D4253377_00 +0000040000000000 4290000000000000_00 +FFF8040000040000 C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +0000080000000000 42A0000000000000_00 +FFFF80000800001F C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9 C3004BF1099291B8_00 +0000100000000000 42B0000000000000_00 +FFFFFEFFFFE0007F C2700001FFF81000_00 +FFFFFFFFFFFFCFBE C0C8210000000000_00 +0000200000000000 42C0000000000000_00 +0000000901FFFFFD 422203FFFFFA0000_00 +FEC01FECA24DE1B0 C373FE0135DB21E5_00 +0000400000000000 42D0000000000000_00 +F7FFFFFFDFFF7FFF C3A0000000400100_01 +F858A66761669936 C39E9D66627A659B_01 +0000800000000000 42E0000000000000_00 +FFFEFF800000003E C2F007FFFFFFFC20_00 +F716EA43FAC45C97 C3A1D22B780A7746_01 +0001000000000000 42F0000000000000_00 +FFFFFFFFFFFFFFC6 C04D000000000000_00 +0024D70EC7661FD8 43426B8763B30FEC_00 +0002000000000000 4300000000000000_00 +C07FFFFFFFFFFFFE C3CFC00000000000_01 +FFD956DBD0AEE817 C343549217A88BF4_01 +0004000000000000 4310000000000000_00 +020003EFFFFFFFFE 4380001F80000000_01 +FFFFFFFFFFFF4300 C0E7A00000000000_00 +0008000000000000 4320000000000000_00 +4000000004002000 43D0000000010008_00 +C12EDF40F41F6021 C3CF68905F85F04F_01 +0010000000000000 4330000000000000_00 +FF9000000000001D C35BFFFFFFFFFFF8_01 +FFFFFFF83DE950F6 C21F085ABC280000_00 +0020000000000000 4340000000000000_00 +800003FFFFFC0000 C3DFFFFF00000100_00 +FE2B59CB3A604D69 C37D4A634C59FB29_01 +0040000000000000 4350000000000000_00 +7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFF0_01 +000000A37C210862 42646F84210C4000_00 +0080000000000000 4360000000000000_00 +0002000002000002 4300000010000010_00 +FFFFB65CD8617789 C2D268C9E7A21DC0_00 +0100000000000000 4370000000000000_00 +00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D C0AFC60000000000_00 +0200000000000000 4380000000000000_00 +1000008000003FFF 43B0000080000040_01 +000000000D098D19 41AA131A32000000_00 +0400000000000000 4390000000000000_00 +03FFFFFFFFFFF5FF 438FFFFFFFFFFFB0_01 +000006B3BD2C7BEF 429ACEF4B1EFBC00_00 +0800000000000000 43A0000000000000_00 +00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 +1000000000000000 43B0000000000000_00 +001FFFC000000FFD 433FFFC000000FFD_00 +FFFFFFFFFFFFFF21 C06BE00000000000_00 +2000000000000000 43C0000000000000_00 +0000000041DFFFFF 41D077FFFFC00000_00 +FFFFFFFFFC648262 C18CDBECF0000000_00 +4000000000000000 43D0000000000000_00 +C0001FFFFFFFFFFB C3CFFFF000000000_01 +FFFFFF7353AC45D2 C261958A7745C000_00 +8000000000000000 C3E0000000000000_00 +FFFFFFFFFFE7EFFF C138100100000000_00 +0000000000A1202D 41642405A0000000_00 +C000000000000000 C3D0000000000000_00 +FFFFFFFFFFFF5F7F C0E4102000000000_00 +000000000040CA70 4150329C00000000_00 +E000000000000000 C3C0000000000000_00 +0000200201FFFFFE 42C00100FFFFFF00_00 +00000003B55D87D4 420DAAEC3EA00000_00 +F000000000000000 C3B0000000000000_00 +FF80000DFFFFFFFF C35FFFFC80000000_01 +000000010510FAEF 41F0510FAEF00000_00 +F800000000000000 C3A0000000000000_00 +0003FFF00000000F 430FFF8000000078_00 +000000000000724A 40DC928000000000_00 +FC00000000000000 C390000000000000_00 +FFFFFFDF80000002 C2403FFFFFFF0000_00 +0000000000000064 4059000000000000_00 +FE00000000000000 C380000000000000_00 +FEFFFFFFFFF800FE C370000000007FF0_01 +FFFFFFC2C6222702 C24E9CEEEC7F0000_00 +FF00000000000000 C370000000000000_00 +0000000408000002 4210200000080000_00 +000000E96DF1CB41 426D2DBE39682000_00 +FF80000000000000 C360000000000000_00 +007FFFFFFFFFF9FE 435FFFFFFFFFFE80_01 +F727F174DEE7DC85 C3A1B01D16423046_01 +FFC0000000000000 C350000000000000_00 +8000000003FFFEFE C3DFFFFFFFFF0000_01 +FFFFFFFFFFF0BD5B C12E854A00000000_00 +FFE0000000000000 C340000000000000_00 +0BEFFFFFFFFFFFFF 43A7E00000000000_01 +000000000002790C 4103C86000000000_00 +FFF0000000000000 C330000000000000_00 +FFFFFFFFFFEFFBFA C130040600000000_00 +000000169E75DF01 42369E75DF010000_00 +FFF8000000000000 C320000000000000_00 +00000007FEFFDFFF 421FFBFF7FFC0000_00 +000000000000000E 402C000000000000_00 +FFFC000000000000 C310000000000000_00 +0003FFFE0007FFFE 430FFFF0003FFFF0_00 +FFFFFFFFFFF28622 C12AF3BC00000000_00 +FFFE000000000000 C300000000000000_00 +FFFFFF7FFFFDF7FF C260000041002000_00 +00072F0EC496FE21 431CBC3B125BF884_00 +FFFF000000000000 C2F0000000000000_00 +DFBFFFFFFFFFFFFE C3C0200000000000_01 +0000000000FC1FCA 416F83F940000000_00 +FFFF800000000000 C2E0000000000000_00 +00000FFF800FFFFE 42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE C2E5CD636AC7A640_00 +FFFFC00000000000 C2D0000000000000_00 +00000002100007FD 420080003FE80000_00 +FFFFFFFFFFC2D8FE C14E938100000000_00 +FFFFE00000000000 C2C0000000000000_00 +000000000007FF6E 411FFDB800000000_00 +000000000001766E 40F766E000000000_00 +FFFFF00000000000 C2B0000000000000_00 +0040000400000002 4350000100000001_01 +0000000000007841 40DE104000000000_00 +FFFFF80000000000 C2A0000000000000_00 +3DFFFFFFFFFFFF7E 43CF000000000000_01 +FFFFFFE549E17E30 C23AB61E81D00000_00 +FFFFFC0000000000 C290000000000000_00 +FFFFFFFFFFFFFEE1 C071F00000000000_00 +FFFFFFFFFFFFFFE7 C039000000000000_00 +FFFFFE0000000000 C280000000000000_00 +000000000EFFFFDF 41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73 C061A00000000000_00 +FFFFFF0000000000 C270000000000000_00 +FD00000008000000 C387FFFFFFC00000_00 +000000000001DBB1 40FDBB1000000000_00 +FFFFFF8000000000 C260000000000000_00 +FFFFFFFFFFF8007F C11FFE0400000000_00 +FFFFFFFEFD10A515 C1F02EF5AEB00000_00 +FFFFFFC000000000 C250000000000000_00 +FFEFFFFFFFFFFFFE C330000000000002_00 +FAB02984F6283B6C C3953F59EC275F12_01 +FFFFFFE000000000 C240000000000000_00 +FFFFFFBC000001FE C250FFFFFF808000_00 +FEB087C6B9FE7FE0 C374F78394601802_00 +FFFFFFF000000000 C230000000000000_00 +FFF80001000007FE C31FFFFBFFFFE008_00 +00F2762EA6837956 436E4EC5D4D06F2B_01 +FFFFFFF800000000 C220000000000000_00 +FFF7E0FFFFFFFFFE C3203E0000000004_00 +00002E1175484626 42C708BAA4231300_00 +FFFFFFFC00000000 C210000000000000_00 +0000200020000FFE 42C000100007FF00_00 +000000000000068F 409A3C0000000000_00 +FFFFFFFE00000000 C200000000000000_00 +021FFFFFFFFBFFFF 4380FFFFFFFFE000_01 +FFFFFFFFFFFFFFF9 C01C000000000000_00 +FFFFFFFF00000000 C1F0000000000000_00 +FFFFFFD0000FFFFD C247FFF800018000_00 +000000BDF6658B83 4267BECCB1706000_00 +FFFFFFFF80000000 C1E0000000000000_00 +1000001FFDFFFFFF 43B000001FFE0000_01 +0000000000003B5B 40CDAD8000000000_00 +FFFFFFFFC0000000 C1D0000000000000_00 +FFFFFFBFFE0FFFFF C250007C00004000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +FFFFFFFFE0000000 C1C0000000000000_00 +FFFFFFFBF00007FF C2103FFFE0040000_00 +01E986274F48EAAD 437E986274F48EAB_01 +FFFFFFFFF0000000 C1B0000000000000_00 +1FFFFFFDFFFFFF7F 43BFFFFFFE000000_01 +FFFFFFFFFFFFCB5A C0CA530000000000_00 +FFFFFFFFF8000000 C1A0000000000000_00 +7FF000000000FFFF 43DFFC0000000040_01 +00000003C2717FC3 420E138BFE180000_00 +FFFFFFFFFC000000 C190000000000000_00 +FFFFFFE00008001F C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA C130542600000000_00 +FFFFFFFFFE000000 C180000000000000_00 +0200000000000002 4380000000000001_01 +FFFFFFFFF8FDA53F C19C096B04000000_00 +FFFFFFFFFF000000 C170000000000000_00 +F6000003FFFFFFFE C3A3FFFFF8000000_01 +FFFFFFFFFFFFFFD0 C048000000000000_00 +FFFFFFFFFF800000 C160000000000000_00 +FFFFFFFFFFBFFF7E C150002080000000_00 +00000000EE0FEA62 41EDC1FD4C400000_00 +FFFFFFFFFFC00000 C150000000000000_00 +0000007FFF9FFFFD 425FFFE7FFFF4000_00 +00000037F35EDC1D 424BF9AF6E0E8000_00 +FFFFFFFFFFE00000 C140000000000000_00 +FFFFFFF7FDFFFF7D C220040001060000_00 +00000000000001AD 407AD00000000000_00 +FFFFFFFFFFF00000 C130000000000000_00 +FFFFFF0000100020 C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A 43C3F8B3FDE3FE30_01 +FFFFFFFFFFF80000 C120000000000000_00 +003FFFFFFFFC0001 434FFFFFFFFE0001_01 +000E48F9F4EBD30E 432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000 C110000000000000_00 +DFFFFFFFFFFBFFFE C3C0000000000200_01 +FC91C23EE8C9424F C38B71EE08B9B5ED_01 +FFFFFFFFFFFE0000 C100000000000000_00 +F7DFFBFFFFFFFFFE C3A0400800000000_01 +000000002CAE080C 41C6570406000000_00 +FFFFFFFFFFFF0000 C0F0000000000000_00 +FFFFC00010000020 C2CFFFF7FFFFF000_00 +04D921F917B20E40 43936487E45EC839_00 +FFFFFFFFFFFF8000 C0E0000000000000_00 +F8000FFFFFFFFFFD C39FFFC000000000_01 +FFF17C566BC7D811 C32D075328704FDE_00 +FFFFFFFFFFFFC000 C0D0000000000000_00 +00000000000000FE 406FC00000000000_00 +FFF82AC14930D386 C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000 C0C0000000000000_00 +00000000000003FC 408FE00000000000_00 +000E62EC60E119FC 432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000 C0B0000000000000_00 +FFFFEFF7FF7FFFFE C2B0080080000200_00 +0E2B1ECF210EEDC5 43AC563D9E421DDC_01 +FFFFFFFFFFFFF800 C0A0000000000000_00 +00000000007FFF1F 415FFFC7C0000000_00 +FFFFFE534F5676F7 C27ACB0A98909000_00 +FFFFFFFFFFFFFC00 C090000000000000_00 +0000001004FFFFFD 423004FFFFFD0000_00 +0000035C939669F1 428AE49CB34F8800_00 +FFFFFFFFFFFFFE00 C080000000000000_00 +1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFE_01 +FFFFFFFFFFFFFF91 C05BC00000000000_00 +FFFFFFFFFFFFFF00 C070000000000000_00 +01FFFFFFFBFFEFFE 437FFFFFFFBFFF00_01 +000000000000016E 4076E00000000000_00 +FFFFFFFFFFFFFF80 C060000000000000_00 +FFF7FFFFFFFFF7FD C320000000001006_00 +FFFFF8E2BCFAC553 C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0 C050000000000000_00 +FFFFFBFFFFFE0FFE C290000007C00800_00 +00000001A4E704BF 41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0 C040000000000000_00 +1400007FFFFFFFFD 43B4000080000000_01 +FFFFFFFC93B187B4 C20B6273C2600000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +40000000007FFFFD 43D0000000002000_01 +000000000067D468 4159F51A00000000_00 +FFFFFFFFFFFFFFF8 C020000000000000_00 +007FFEFFFFFBFFFE 435FFFBFFFFF0000_01 +FFFFFFE26CEC79F8 C23D931386080000_00 +FFFFFFFFFFFFFFFC C010000000000000_00 +00FFFFFF000000FF 436FFFFFE0000020_01 +FFFFFFFFE0D3983A C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE C000000000000000_00 +00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF BFF0000000000000_00 +000008000000027E 42A000000004FC00_00 +000000000000F4E8 40EE9D0000000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFF83FFDF C15F000840000000_00 +00000E11407887B2 42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +04000003FFFFFFF6 4390000010000000_01 +0000000000000513 40944C0000000000_00 +FFFFFFFFFFFFFFF7 C022000000000000_00 +BFFC00000000003E C3D000FFFFFFFFFF_01 +00000008D7BBB75B 4221AF776EB60000_00 +FFFFFFFFFFFFFFEF C031000000000000_00 +000FFFFBFFFC0000 432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23 C14952EE80000000_00 +FFFFFFFFFFFFFFDF C040800000000000_00 +FFBFDFFFBFFFFFFF C350080010000000_01 +000000000000007F 405FC00000000000_00 +FFFFFFFFFFFFFFBF C050400000000000_00 +00000007FF800003 421FFE00000C0000_00 +000000000002BB02 4105D81000000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEE7FF C0F1801000000000_00 +00264B2B9BAD0DA2 43432595CDD686D1_00 +FFFFFFFFFFFFFEFF C070100000000000_00 +0000000000100803 4130080300000000_00 +FF9B1DCB9F857D5E C359388D181EA0A8_01 +FFFFFFFFFFFFFDFF C080080000000000_00 +FFFFFFBFFFFFEFEE C250000004048000_00 +F6FD7542899C1C6F C3A205157AECC7C7_01 +FFFFFFFFFFFFFBFF C090040000000000_00 +FF800000004001FF C35FFFFFFFEFFF80_01 +0000000002BE4932 4185F24990000000_00 +FFFFFFFFFFFFF7FF C0A0020000000000_00 +00001004000FFFFE 42B004000FFFFE00_00 +FFFFFF9DAA0123E0 C258957FB7080000_00 +FFFFFFFFFFFFEFFF C0B0010000000000_00 +00000001FDFFFDFE 41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF C0C0008000000000_00 +FE0FE00000000000 C37F020000000000_00 +0779ED944A4E2779 439DE7B65129389E_01 +FFFFFFFFFFFFBFFF C0D0004000000000_00 +FBFFFE0400000000 C3900007F0000000_00 +0000010127E03666 4270127E03666000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +FFFFF0200000FFFE C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEFFFF C0F0001000000000_00 +FFEFFE0000080000 C33001FFFFF80000_00 +FFFFFFFFFD3354EA C1866558B0000000_00 +FFFFFFFFFFFDFFFF C100000800000000_00 +003FF0000003FFFE 434FF8000001FFFF_00 +0000006375B23F7B 4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF C110000400000000_00 +000407FFFFFFFFF6 43101FFFFFFFFFD8_00 +0000000092117F38 41E2422FE7000000_00 +FFFFFFFFFFF7FFFF C120000200000000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +00000000000008BE 40A17C0000000000_00 +FFFFFFFFFFEFFFFF C130000100000000_00 +004000020FFFFFFF 4350000084000000_01 +FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF C140000080000000_00 +00FFFFFFFFFFFFFD 4370000000000000_01 +00000023C2C6F284 4241E16379420000_00 +FFFFFFFFFFBFFFFF C150000040000000_00 +FFFDDFFFFFFFFFFD C301000000000018_00 +00000000746356C4 41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF C160000020000000_00 +010000000000BFFF 4370000000000C00_01 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFEFFFFFF C170000010000000_00 +FFFFBF7FFBFFFFFE C2D0200100000080_00 +00000006386CE889 4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF C180000008000000_00 +F00000F7FFFFFFFF C3AFFFFE10000000_01 +FFFDFC53090C46A4 C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +0000000000800047 41600008E0000000_00 +FFFFFFFFD693872E C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF C1A0000002000000_00 +000000007FBFFBFF 41DFEFFEFFC00000_00 +00000026A7845E35 424353C22F1A8000_00 +FFFFFFFFEFFFFFFF C1B0000001000000_00 +FFFFFFDFFFFFFBFD C240000002018000_00 +000000001433D14C 41B433D14C000000_00 +FFFFFFFFDFFFFFFF C1C0000000800000_00 +0001FFFFFFE0000E 42FFFFFFFE0000E0_00 +F0F23E8068D3D84A C3AE1B82FF2E584F_01 +FFFFFFFFBFFFFFFF C1D0000000400000_00 +F7FFBFFFFFFFBFFF C3A0008000000080_01 +FFFFBD29B7459087 C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF C1E0000000200000_00 +FFFFFFF8FFFFBFFF C21C000100040000_00 +FFFFFFFFFFEDDC06 C13223FA00000000_00 +FFFFFFFEFFFFFFFF C1F0000000100000_00 +FFFFFFF80001FFFF C21FFFF800040000_00 +0000000000002FF9 40C7FC8000000000_00 +FFFFFFFDFFFFFFFF C200000000080000_00 +004000040000FFFF 4350000100004000_01 +FFFFFFFFFFFFFFF1 C02E000000000000_00 +FFFFFFFBFFFFFFFF C210000000040000_00 +C0000000007FFFFA C3CFFFFFFFFFC000_01 +FFFFFFFFFE053E2B C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF C220000000020000_00 +7FFE000007FFFFFF 43DFFF8000020000_01 +000000000000000D 402A000000000000_00 +FFFFFFEFFFFFFFFF C230000000010000_00 +F80000000001007E C39FFFFFFFFFFBFE_01 +FFFFED48424AD9D6 C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF C240000000008000_00 +FFFFFE0001FEFFFF C27FFFE010001000_00 +000000000000013B 4073B00000000000_00 +FFFFFFBFFFFFFFFF C250000000004000_00 +0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 +4A16BD4128090C83 43D285AF504A0244_01 +FFFFFF7FFFFFFFFF C260000000002000_00 +00FFF7FFFF7FFFFE 436FFEFFFFF00000_01 +0000000000000006 4018000000000000_00 +FFFFFEFFFFFFFFFF C270000000001000_00 +FBFFFFBFFFBFFFFF C390000100010000_01 +00000000000001BA 407BA00000000000_00 +FFFFFDFFFFFFFFFF C280000000000800_00 +0000000040000082 41D0000020800000_00 +FF07A2BF5B689F89 C36F0BA81492EC0E_01 +FFFFFBFFFFFFFFFF C290000000000400_00 +0000001FF8000008 423FF80000080000_00 +F87CAA7DE672DE8B C39E0D5608663485_01 +FFFFF7FFFFFFFFFF C2A0000000000200_00 +07FFF80000000002 439FFFE000000001_01 +0000000010A1E5B8 41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF C2B0000000000100_00 +F7FFFFE00007FFFF C3A000003FFFF000_01 +FFFFFFFFFFF6ADFC C122A40800000000_00 +FFFFDFFFFFFFFFFF C2C0000000000080_00 +FFFFFF03FFFFFFC0 C26F800000080000_00 +EA579475948F0032 C3B5A86B8A6B70FF_01 +FFFFBFFFFFFFFFFF C2D0000000000040_00 +FC00000000003FF6 C38FFFFFFFFFFE00_01 +002E677AC313BF60 434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF C2E0000000000020_00 +02000007FF7FFFFF 438000003FFC0000_01 +0000000E999639F1 422D332C73E20000_00 +FFFEFFFFFFFFFFFF C2F0000000000010_00 +FFFF83FFFFFFFFBE C2DF000000001080_00 +000000000001537D 40F537D000000000_00 +FFFDFFFFFFFFFFFF C300000000000008_00 +EFFFFFC00000003D C3B000003FFFFFFF_01 +FFFFFFF21FEDFD35 C22BC02405960000_00 +FFFBFFFFFFFFFFFF C310000000000004_00 +FFFFFFF0000007FE C22FFFFFF0040000_00 +FFFFFFFFFFDE0839 C140FBE380000000_00 +FFF7FFFFFFFFFFFF C320000000000002_00 +0000007FFFE000FF 425FFFF8003FC000_00 +FFFFFFFF79F30F48 C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF C330000000000001_00 +FFFFFC13FFFFFFFD C28F600000001800_00 +0000000000001B85 40BB850000000000_00 +FFDFFFFFFFFFFFFF C340000000000000_01 +000008000007FFFE 42A000000FFFFC00_00 +12DB4409E5AE87E6 43B2DB4409E5AE88_01 +FFBFFFFFFFFFFFFF C350000000000000_01 +FFFFFFFFFFF7BFEE C120802400000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FF7FFFFFFFFFFFFF C360000000000000_01 +000000001040FFFE 41B040FFFE000000_00 +00000909A09C13D3 42A213413827A600_00 +FEFFFFFFFFFFFFFF C370000000000000_01 +FFFFFF01FFFFFF7F C26FC00000102000_00 +FFFFFF72E7D2575D C261A305B5146000_00 +FDFFFFFFFFFFFFFF C380000000000000_01 +FFFFFFFFFFFEFFDB C0F0025000000000_00 +0000000000000017 4037000000000000_00 +FBFFFFFFFFFFFFFF C390000000000000_01 +100000001FFFFFF6 43B0000000200000_01 +000000114B12EF51 42314B12EF510000_00 +F7FFFFFFFFFFFFFF C3A0000000000000_01 +0407FFFFFFFFFEFF 43901FFFFFFFFFFC_01 +FFFFFF769F3A5C2C C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF C3B0000000000000_01 +FFFFFFFDF7FFFFFD C200400000180000_00 +FFFFFFFFFFFFFFF2 C02C000000000000_00 +DFFFFFFFFFFFFFFF C3C0000000000000_01 +FFFFFFFFFE0007FF C17FFF8010000000_00 +000000000000001E 403E000000000000_00 +BFFFFFFFFFFFFFFF C3D0000000000000_01 +FFF800000009FFFF C31FFFFFFFD80004_00 +0000000000007AA4 40DEA90000000000_00 +7FFFFFFFFFFFFFFF 43E0000000000000_01 +4080000000FFFFFF 43D0200000004000_01 +000000000DE7601D 41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF 43D0000000000000_01 +FFCFFFFFFFBFFFFE C348000000200001_00 +FFFFFFFFFFFFFFCA C04B000000000000_00 +1FFFFFFFFFFFFFFF 43C0000000000000_01 +000080400000003F 42E00800000007E0_00 +00000000001F75A5 413F75A500000000_00 +0FFFFFFFFFFFFFFF 43B0000000000000_01 +FFFFFFEFFFFFCFFE C230000030020000_00 +FFFFFEE775887420 C27188A778BE0000_00 +07FFFFFFFFFFFFFF 43A0000000000000_01 +00000000000801FE 412003FC00000000_00 +0000000000213FF1 41409FF880000000_00 +03FFFFFFFFFFFFFF 4390000000000000_01 +07FEFFFFFFFFFFEE 439FFC0000000000_01 +0000000000000004 4010000000000000_00 +01FFFFFFFFFFFFFF 4380000000000000_01 +0000000820000003 4220400000060000_00 +FFFFFFF9AD105214 C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF 4370000000000000_01 +FFFFF00FFFFFFFBE C2AFE00000008400_00 +FFFFFFFFFFCC48E7 C149DB8C80000000_00 +007FFFFFFFFFFFFF 4360000000000000_01 +00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB C16E8B26A0000000_00 +003FFFFFFFFFFFFF 4350000000000000_01 +FFFFFF7FBFFFFFBF C260080000082000_00 +FFFFFFFFFFF24425 C12B77B600000000_00 +001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 +200000001FFBFFFF 43C00000000FFE00_01 +FFFFFF4E7115EC53 C26631DD4275A000_00 +000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF C29FF00000010400_00 +FFFFFC2E539ADCFE C28E8D6329181000_00 +0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +00000055084732F3 42554211CCBCC000_00 +0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00 C3D0002000000000_01 +FFFFFFFFFFFF8543 C0DEAF4000000000_00 +0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 +0000001FFBFFE000 423FFBFFE0000000_00 +FFFFFFFFFFFE491B C0FB6E5000000000_00 +0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 +FC00200000001FFE C38FFEFFFFFFFF00_01 +FFFFF16898822A24 C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE 43CFFF8200000000_01 +FFFFFF8FFE18C7BF C25C0079CE104000_00 +00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD C270001000003000_00 +00F03620C1266ED9 436E06C41824CDDC_01 +00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF C3D0204000000000_01 +FFFFFFFFFFFFFFD5 C045800000000000_00 +00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE C31000001FF00008_00 +0000000000068684 411A1A1000000000_00 +000007FFFFFFFFFF 429FFFFFFFFFFC00_00 +DFFFFFE00000001E C3C000000FFFFFFF_01 +FFFFFFFFFFFFECF5 C0B30B0000000000_00 +000003FFFFFFFFFF 428FFFFFFFFFF800_00 +FFFF00400000FFFF C2EFF7FFFFE00020_00 +0000000000000002 4000000000000000_00 +000001FFFFFFFFFF 427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE C390000000000108_01 +0000000000000BC9 40A7920000000000_00 +000000FFFFFFFFFF 426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE C3DFE00000000008_01 +FFC274E35A70CD76 C34EC58E52C79945_00 +0000007FFFFFFFFF 425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD 43AFFFFFFFFE0000_01 +FFFFFFFF00E73AFC C1EFE318A0800000_00 +0000003FFFFFFFFF 424FFFFFFFFF8000_00 +FFC000000001000E C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9 C0FEA17000000000_00 +0000001FFFFFFFFF 423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 +0000000000000033 4049800000000000_00 +0000000FFFFFFFFF 422FFFFFFFFE0000_00 +000000001FFFBFFF 41BFFFBFFF000000_00 +FFFFFFEE6B141E1B C23194EBE1E50000_00 +00000007FFFFFFFF 421FFFFFFFFC0000_00 +FFFFFFFFF60007FF C1A3FFF002000000_00 +00000001AB310BA6 41FAB310BA600000_00 +00000003FFFFFFFF 420FFFFFFFF80000_00 +0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195 C0ACD60000000000_00 +00000001FFFFFFFF 41FFFFFFFFF00000_00 +FFFFFFFF8000000B C1DFFFFFFD400000_00 +00000019BA8D5559 4239BA8D55590000_00 +00000000FFFFFFFF 41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9 C390040000000000_01 +FFFFFFB6F062822D C25243E75F74C000_00 +000000007FFFFFFF 41DFFFFFFFC00000_00 +0001000000000082 42F0000000000820_00 +01CEAD9E2FB104A4 437CEAD9E2FB104B_01 +000000003FFFFFFF 41CFFFFFFF800000_00 +000003FFFFFFFF7C 428FFFFFFFFBE000_00 +FFFFFFFFFD681E78 C184BF0C40000000_00 +000000001FFFFFFF 41BFFFFFFF000000_00 +00002000400001FF 42C000200000FF80_00 +0000000000000018 4038000000000000_00 +000000000FFFFFFF 41AFFFFFFE000000_00 +3FFF80000000003E 43CFFFC000000001_01 +FFFFFFFFFFFFFF95 C05AC00000000000_00 +0000000007FFFFFF 419FFFFFFC000000_00 +010000BFFFFFFFFF 4370000C00000000_01 +0000001697087B19 423697087B190000_00 +0000000003FFFFFF 418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD C390000000004400_01 +0000000E64BDFC55 422CC97BF8AA0000_00 +0000000001FFFFFF 417FFFFFF0000000_00 +FC00000001FFFFFE C38FFFFFFFF00000_01 +FFFED156A62AB849 C2F2EA959D547B70_00 +0000000000FFFFFF 416FFFFFE0000000_00 +FFFFFFF83FEFFFFD C21F0040000C0000_00 +00015354EAE7C259 42F5354EAE7C2590_00 +00000000007FFFFF 415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFF0F4DF3C75 C22E164187160000_00 +00000000003FFFFF 414FFFFF80000000_00 +FFFA000000001FFF C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000001FFFFF 413FFFFF00000000_00 +FFFFFFFFFF7FFE40 C160003800000000_00 +FFFFFFDB5433CB9B C24255E61A328000_00 +00000000000FFFFF 412FFFFE00000000_00 +FFFFFDFFDFFDFFFD C280010010001800_00 +FFFFFFFFFFDEAE1F C140A8F080000000_00 +000000000007FFFF 411FFFFC00000000_00 +FFFFFFFFF0080006 C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7 C1F88CA213900000_00 +000000000003FFFF 410FFFF800000000_00 +00000001FBFFFFFF 41FFBFFFFFF00000_00 +000003757D8B12ED 428BABEC58976800_00 +000000000001FFFF 40FFFFF000000000_00 +FFFFFE07F7FFFFFF C27F808000001000_00 +00000A654064E046 42A4CA80C9C08C00_00 +000000000000FFFF 40EFFFE000000000_00 +08000000000017FF 43A0000000000030_01 +FFFFFFFFFFFFFFE7 C039000000000000_00 +0000000000007FFF 40DFFFC000000000_00 +07FFFFFFFFFFFDF6 439FFFFFFFFFFFF8_01 +FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 +0000000000003FFF 40CFFF8000000000_00 +0000300004000000 42C8000200000000_00 +FFFFFFF70B77F34F C221E91019620000_00 +0000000000001FFF 40BFFF0000000000_00 +FFFFFF80006FFFFE C25FFFE400008000_00 +0000013EB4D67EC8 4273EB4D67EC8000_00 +0000000000000FFF 40AFFE0000000000_00 +BFFFDFFFFBFFFFFF C3D0000800010000_01 +0005CEAF34EA1DC7 43173ABCD3A8771C_00 +00000000000007FF 409FFC0000000000_00 +00004800007FFFFD 42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000000003FF 408FF80000000000_00 +0000000200001000 4200000080000000_00 +00000000000360D0 410B068000000000_00 +00000000000001FF 407FF00000000000_00 +01003FFFFFFFFFFC 4370040000000000_01 +00C000708FF1BA51 4368000E11FE374B_01 +00000000000000FF 406FE00000000000_00 +F802000003FFFFFF C39FF7FFFFF00000_01 +0F9E07DCC0BDC061 43AF3C0FB9817B81_01 +000000000000007F 405FC00000000000_00 +03FF0000000000FF 438FF80000000008_01 +FFFFFFE1B9B2A079 C23E464D5F870000_00 +000000000000003F 404F800000000000_00 +FFF80000000080FF C31FFFFFFFFDFC04_00 +00000000001EB5B4 413EB5B400000000_00 +000000000000001F 403F000000000000_00 +000000000077FBFE 415DFEFF80000000_00 +00000000005AC607 4156B181C0000000_00 +000000000000000F 402E000000000000_00 +FFFFFFFEF80000FF C1F07FFFF0100000_00 +000005C5B9D66984 429716E759A61000_00 +0000000000000007 401C000000000000_00 +C001FFFFFFF00000 C3CFFF0000000800_00 +00001D06B372AA06 42BD06B372AA0600_00 +0000000000000003 4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_rz.tv b/wally-pipelined/testbench/fp/i64_f64_rz.tv new file mode 100644 index 000000000..315fa3fe4 --- /dev/null +++ b/wally-pipelined/testbench/fp/i64_f64_rz.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F 439FFFF7FFFFFFFD_01 +0000000032CC8B7A 41C96645BD000000_00 +0000000000000000 0000000000000000_00 +FFFFFFFFC0003FFE C1CFFFE001000000_00 +032C857F319EDE38 4389642BF98CF6F1_01 +0000000000000001 3FF0000000000000_00 +FFFFFBFFFFF8003E C29000001FFF0800_00 +00394C79B6D3007B 434CA63CDB69803D_01 +0000000000000002 4000000000000000_00 +FBFFFFF0000001FF C39000003FFFFFF8_01 +0000000001AE458D 417AE458D0000000_00 +0000000000000004 4010000000000000_00 +00040008000007FE 4310002000001FF8_00 +F9EB456140D88764 C39852EA7AFC9DE2_01 +0000000000000008 4020000000000000_00 +FFFFE400FFFFFFFE C2BBFF0000000200_00 +07DE834A248EDF36 439F7A0D28923B7C_01 +0000000000000010 4030000000000000_00 +00000003FF001FFF 420FF800FFF80000_00 +FFFFFFFFFFE385E2 C13C7A1E00000000_00 +0000000000000020 4040000000000000_00 +F0041FFFFFFFFFFF C3AFF7C000000000_01 +000000059EB1FD45 42167AC7F5140000_00 +0000000000000040 4050000000000000_00 +FFFFFFFFFFFCFFF9 C108003800000000_00 +FFFFFFFFFFFEDDFE C0F2202000000000_00 +0000000000000080 4060000000000000_00 +000000000003FF00 410FF80000000000_00 +00000000C89FF56B 41E913FEAD600000_00 +0000000000000100 4070000000000000_00 +000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEBF_01 +0000000000000200 4080000000000000_00 +FFFDF803FFFFFFFF C3003FE000000008_00 +FFFFFFFFFFF4766B C127132A00000000_00 +0000000000000400 4090000000000000_00 +0000080100000FFE 42A00200001FFC00_00 +000000000000000C 4028000000000000_00 +0000000000000800 40A0000000000000_00 +0048000000100000 4352000000040000_00 +FFE662A109109D0A C3399D5EF6EF62F6_00 +0000000000001000 40B0000000000000_00 +C000000037FFFFFE C3CFFFFFFFE40000_01 +FFFFFFFFFFFFFFE4 C03C000000000000_00 +0000000000002000 40C0000000000000_00 +F801000000100000 C39FFBFFFFFFC000_00 +FE114B79075F70EE C37EEB486F8A08F1_01 +0000000000004000 40D0000000000000_00 +100000000001003E 43B0000000000100_01 +00000000000003AC 408D600000000000_00 +0000000000008000 40E0000000000000_00 +200000FFFFFFF800 43C000007FFFFFFC_00 +00000044A3A3DBE5 425128E8F6F94000_00 +0000000000010000 40F0000000000000_00 +FFE0003EFFFFFFFF C33FFFC100000001_00 +FFFFFFFFFFFF1A91 C0ECADE000000000_00 +0000000000020000 4100000000000000_00 +FFFFF7C3FFFFFFFD C2A0780000000600_00 +0000000000003309 40C9848000000000_00 +0000000000040000 4110000000000000_00 +000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58 C065000000000000_00 +0000000000080000 4120000000000000_00 +FFFFFFDE01FFFFFE C240FF0000010000_00 +0000000000002980 40C4C00000000000_00 +0000000000100000 4130000000000000_00 +00000000FFF07FFF 41EFFE0FFFE00000_00 +000000000000005D 4057400000000000_00 +0000000000200000 4140000000000000_00 +000020FFDFFFFFFF 42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 +0000000000400000 4150000000000000_00 +E0000000003FFFDF C3BFFFFFFFFFC000_01 +FFFFFDE3C1DEC43C C280E1F109DE2000_00 +0000000000800000 4160000000000000_00 +FFFF00000BFFFFFD C2EFFFFE80000060_00 +000000000030FFBE 41487FDF00000000_00 +0000000001000000 4170000000000000_00 +FFFE000007FFEFFD C2FFFFFF80010030_00 +FFFFFFFFEFDEED86 C1B021127A000000_00 +0000000002000000 4180000000000000_00 +F3FFFFFFFFBFFFFE C3A8000000008000_01 +000000001DA3FF45 41BDA3FF45000000_00 +0000000004000000 4190000000000000_00 +FFFFFFFF00010007 C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54 C1F64E434AC00000_00 +0000000008000000 41A0000000000000_00 +00004000004001FE 42D0000010007F80_00 +F27DD19DE6563714 C3AB045CC4335391_01 +0000000010000000 41B0000000000000_00 +FFC00000004007FE C34FFFFFFFDFFC01_00 +000000000001A359 40FA359000000000_00 +0000000020000000 41C0000000000000_00 +0000000003C000FE 418E0007F0000000_00 +FFFFFFFFFE62EC20 C179D13E00000000_00 +0000000040000000 41D0000000000000_00 +000000003FFFFFFD 41CFFFFFFE800000_00 +000000000000285F 40C42F8000000000_00 +0000000080000000 41E0000000000000_00 +FFFFFFFFBFFFF00F C1D00003FC400000_00 +FFFFF836F99DBAA8 C29F241989156000_00 +0000000100000000 41F0000000000000_00 +00000020003FFEFE 4240001FFF7F0000_00 +0033466832042D47 4349A334190216A3_01 +0000000200000000 4200000000000000_00 +FFFFFFFFFFFFF887 C09DE40000000000_00 +00000000003829C8 414C14E400000000_00 +0000000400000000 4210000000000000_00 +00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 +0000000FB77C672B 422F6EF8CE560000_00 +0000000800000000 4220000000000000_00 +08003FFDFFFFFFFE 43A0007FFBFFFFFF_01 +0000000000001B78 40BB780000000000_00 +0000001000000000 4230000000000000_00 +FF7FFFFFFFEFDFFF C360000000020400_01 +0000000000000071 405C400000000000_00 +0000002000000000 4240000000000000_00 +000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86 C05E800000000000_00 +0000004000000000 4250000000000000_00 +0800000000040800 43A0000000000810_00 +FFF8A60D9E19F17E C31D67C987983A08_00 +0000008000000000 4260000000000000_00 +000077FFF0000000 42DDFFFC00000000_00 +FFFFFFFFF7506DBA C1A15F248C000000_00 +0000010000000000 4270000000000000_00 +FFFFFFFFFFFEFBF7 C0F0409000000000_00 +FFFFFFFFFEA42AC9 C175BD5370000000_00 +0000020000000000 4280000000000000_00 +0000107FFFFFDFFD 42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89 C33855C0D4253377_00 +0000040000000000 4290000000000000_00 +FFF8040000040000 C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +0000080000000000 42A0000000000000_00 +FFFF80000800001F C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9 C3004BF1099291B8_00 +0000100000000000 42B0000000000000_00 +FFFFFEFFFFE0007F C2700001FFF81000_00 +FFFFFFFFFFFFCFBE C0C8210000000000_00 +0000200000000000 42C0000000000000_00 +0000000901FFFFFD 422203FFFFFA0000_00 +FEC01FECA24DE1B0 C373FE0135DB21E5_00 +0000400000000000 42D0000000000000_00 +F7FFFFFFDFFF7FFF C3A0000000400100_01 +F858A66761669936 C39E9D66627A659B_01 +0000800000000000 42E0000000000000_00 +FFFEFF800000003E C2F007FFFFFFFC20_00 +F716EA43FAC45C97 C3A1D22B780A7746_01 +0001000000000000 42F0000000000000_00 +FFFFFFFFFFFFFFC6 C04D000000000000_00 +0024D70EC7661FD8 43426B8763B30FEC_00 +0002000000000000 4300000000000000_00 +C07FFFFFFFFFFFFE C3CFC00000000000_01 +FFD956DBD0AEE817 C343549217A88BF4_01 +0004000000000000 4310000000000000_00 +020003EFFFFFFFFE 4380001F7FFFFFFF_01 +FFFFFFFFFFFF4300 C0E7A00000000000_00 +0008000000000000 4320000000000000_00 +4000000004002000 43D0000000010008_00 +C12EDF40F41F6021 C3CF68905F85F04F_01 +0010000000000000 4330000000000000_00 +FF9000000000001D C35BFFFFFFFFFFF8_01 +FFFFFFF83DE950F6 C21F085ABC280000_00 +0020000000000000 4340000000000000_00 +800003FFFFFC0000 C3DFFFFF00000100_00 +FE2B59CB3A604D69 C37D4A634C59FB29_01 +0040000000000000 4350000000000000_00 +7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFEF_01 +000000A37C210862 42646F84210C4000_00 +0080000000000000 4360000000000000_00 +0002000002000002 4300000010000010_00 +FFFFB65CD8617789 C2D268C9E7A21DC0_00 +0100000000000000 4370000000000000_00 +00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D C0AFC60000000000_00 +0200000000000000 4380000000000000_00 +1000008000003FFF 43B000008000003F_01 +000000000D098D19 41AA131A32000000_00 +0400000000000000 4390000000000000_00 +03FFFFFFFFFFF5FF 438FFFFFFFFFFFAF_01 +000006B3BD2C7BEF 429ACEF4B1EFBC00_00 +0800000000000000 43A0000000000000_00 +00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 +1000000000000000 43B0000000000000_00 +001FFFC000000FFD 433FFFC000000FFD_00 +FFFFFFFFFFFFFF21 C06BE00000000000_00 +2000000000000000 43C0000000000000_00 +0000000041DFFFFF 41D077FFFFC00000_00 +FFFFFFFFFC648262 C18CDBECF0000000_00 +4000000000000000 43D0000000000000_00 +C0001FFFFFFFFFFB C3CFFFF000000000_01 +FFFFFF7353AC45D2 C261958A7745C000_00 +8000000000000000 C3E0000000000000_00 +FFFFFFFFFFE7EFFF C138100100000000_00 +0000000000A1202D 41642405A0000000_00 +C000000000000000 C3D0000000000000_00 +FFFFFFFFFFFF5F7F C0E4102000000000_00 +000000000040CA70 4150329C00000000_00 +E000000000000000 C3C0000000000000_00 +0000200201FFFFFE 42C00100FFFFFF00_00 +00000003B55D87D4 420DAAEC3EA00000_00 +F000000000000000 C3B0000000000000_00 +FF80000DFFFFFFFF C35FFFFC80000000_01 +000000010510FAEF 41F0510FAEF00000_00 +F800000000000000 C3A0000000000000_00 +0003FFF00000000F 430FFF8000000078_00 +000000000000724A 40DC928000000000_00 +FC00000000000000 C390000000000000_00 +FFFFFFDF80000002 C2403FFFFFFF0000_00 +0000000000000064 4059000000000000_00 +FE00000000000000 C380000000000000_00 +FEFFFFFFFFF800FE C370000000007FF0_01 +FFFFFFC2C6222702 C24E9CEEEC7F0000_00 +FF00000000000000 C370000000000000_00 +0000000408000002 4210200000080000_00 +000000E96DF1CB41 426D2DBE39682000_00 +FF80000000000000 C360000000000000_00 +007FFFFFFFFFF9FE 435FFFFFFFFFFE7F_01 +F727F174DEE7DC85 C3A1B01D16423046_01 +FFC0000000000000 C350000000000000_00 +8000000003FFFEFE C3DFFFFFFFFF0000_01 +FFFFFFFFFFF0BD5B C12E854A00000000_00 +FFE0000000000000 C340000000000000_00 +0BEFFFFFFFFFFFFF 43A7DFFFFFFFFFFF_01 +000000000002790C 4103C86000000000_00 +FFF0000000000000 C330000000000000_00 +FFFFFFFFFFEFFBFA C130040600000000_00 +000000169E75DF01 42369E75DF010000_00 +FFF8000000000000 C320000000000000_00 +00000007FEFFDFFF 421FFBFF7FFC0000_00 +000000000000000E 402C000000000000_00 +FFFC000000000000 C310000000000000_00 +0003FFFE0007FFFE 430FFFF0003FFFF0_00 +FFFFFFFFFFF28622 C12AF3BC00000000_00 +FFFE000000000000 C300000000000000_00 +FFFFFF7FFFFDF7FF C260000041002000_00 +00072F0EC496FE21 431CBC3B125BF884_00 +FFFF000000000000 C2F0000000000000_00 +DFBFFFFFFFFFFFFE C3C0200000000000_01 +0000000000FC1FCA 416F83F940000000_00 +FFFF800000000000 C2E0000000000000_00 +00000FFF800FFFFE 42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE C2E5CD636AC7A640_00 +FFFFC00000000000 C2D0000000000000_00 +00000002100007FD 420080003FE80000_00 +FFFFFFFFFFC2D8FE C14E938100000000_00 +FFFFE00000000000 C2C0000000000000_00 +000000000007FF6E 411FFDB800000000_00 +000000000001766E 40F766E000000000_00 +FFFFF00000000000 C2B0000000000000_00 +0040000400000002 4350000100000000_01 +0000000000007841 40DE104000000000_00 +FFFFF80000000000 C2A0000000000000_00 +3DFFFFFFFFFFFF7E 43CEFFFFFFFFFFFF_01 +FFFFFFE549E17E30 C23AB61E81D00000_00 +FFFFFC0000000000 C290000000000000_00 +FFFFFFFFFFFFFEE1 C071F00000000000_00 +FFFFFFFFFFFFFFE7 C039000000000000_00 +FFFFFE0000000000 C280000000000000_00 +000000000EFFFFDF 41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73 C061A00000000000_00 +FFFFFF0000000000 C270000000000000_00 +FD00000008000000 C387FFFFFFC00000_00 +000000000001DBB1 40FDBB1000000000_00 +FFFFFF8000000000 C260000000000000_00 +FFFFFFFFFFF8007F C11FFE0400000000_00 +FFFFFFFEFD10A515 C1F02EF5AEB00000_00 +FFFFFFC000000000 C250000000000000_00 +FFEFFFFFFFFFFFFE C330000000000002_00 +FAB02984F6283B6C C3953F59EC275F12_01 +FFFFFFE000000000 C240000000000000_00 +FFFFFFBC000001FE C250FFFFFF808000_00 +FEB087C6B9FE7FE0 C374F78394601802_00 +FFFFFFF000000000 C230000000000000_00 +FFF80001000007FE C31FFFFBFFFFE008_00 +00F2762EA6837956 436E4EC5D4D06F2A_01 +FFFFFFF800000000 C220000000000000_00 +FFF7E0FFFFFFFFFE C3203E0000000004_00 +00002E1175484626 42C708BAA4231300_00 +FFFFFFFC00000000 C210000000000000_00 +0000200020000FFE 42C000100007FF00_00 +000000000000068F 409A3C0000000000_00 +FFFFFFFE00000000 C200000000000000_00 +021FFFFFFFFBFFFF 4380FFFFFFFFDFFF_01 +FFFFFFFFFFFFFFF9 C01C000000000000_00 +FFFFFFFF00000000 C1F0000000000000_00 +FFFFFFD0000FFFFD C247FFF800018000_00 +000000BDF6658B83 4267BECCB1706000_00 +FFFFFFFF80000000 C1E0000000000000_00 +1000001FFDFFFFFF 43B000001FFDFFFF_01 +0000000000003B5B 40CDAD8000000000_00 +FFFFFFFFC0000000 C1D0000000000000_00 +FFFFFFBFFE0FFFFF C250007C00004000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +FFFFFFFFE0000000 C1C0000000000000_00 +FFFFFFFBF00007FF C2103FFFE0040000_00 +01E986274F48EAAD 437E986274F48EAA_01 +FFFFFFFFF0000000 C1B0000000000000_00 +1FFFFFFDFFFFFF7F 43BFFFFFFDFFFFFF_01 +FFFFFFFFFFFFCB5A C0CA530000000000_00 +FFFFFFFFF8000000 C1A0000000000000_00 +7FF000000000FFFF 43DFFC000000003F_01 +00000003C2717FC3 420E138BFE180000_00 +FFFFFFFFFC000000 C190000000000000_00 +FFFFFFE00008001F C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA C130542600000000_00 +FFFFFFFFFE000000 C180000000000000_00 +0200000000000002 4380000000000000_01 +FFFFFFFFF8FDA53F C19C096B04000000_00 +FFFFFFFFFF000000 C170000000000000_00 +F6000003FFFFFFFE C3A3FFFFF8000000_01 +FFFFFFFFFFFFFFD0 C048000000000000_00 +FFFFFFFFFF800000 C160000000000000_00 +FFFFFFFFFFBFFF7E C150002080000000_00 +00000000EE0FEA62 41EDC1FD4C400000_00 +FFFFFFFFFFC00000 C150000000000000_00 +0000007FFF9FFFFD 425FFFE7FFFF4000_00 +00000037F35EDC1D 424BF9AF6E0E8000_00 +FFFFFFFFFFE00000 C140000000000000_00 +FFFFFFF7FDFFFF7D C220040001060000_00 +00000000000001AD 407AD00000000000_00 +FFFFFFFFFFF00000 C130000000000000_00 +FFFFFF0000100020 C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A 43C3F8B3FDE3FE2F_01 +FFFFFFFFFFF80000 C120000000000000_00 +003FFFFFFFFC0001 434FFFFFFFFE0000_01 +000E48F9F4EBD30E 432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000 C110000000000000_00 +DFFFFFFFFFFBFFFE C3C0000000000200_01 +FC91C23EE8C9424F C38B71EE08B9B5ED_01 +FFFFFFFFFFFE0000 C100000000000000_00 +F7DFFBFFFFFFFFFE C3A0400800000000_01 +000000002CAE080C 41C6570406000000_00 +FFFFFFFFFFFF0000 C0F0000000000000_00 +FFFFC00010000020 C2CFFFF7FFFFF000_00 +04D921F917B20E40 43936487E45EC839_00 +FFFFFFFFFFFF8000 C0E0000000000000_00 +F8000FFFFFFFFFFD C39FFFC000000000_01 +FFF17C566BC7D811 C32D075328704FDE_00 +FFFFFFFFFFFFC000 C0D0000000000000_00 +00000000000000FE 406FC00000000000_00 +FFF82AC14930D386 C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000 C0C0000000000000_00 +00000000000003FC 408FE00000000000_00 +000E62EC60E119FC 432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000 C0B0000000000000_00 +FFFFEFF7FF7FFFFE C2B0080080000200_00 +0E2B1ECF210EEDC5 43AC563D9E421DDB_01 +FFFFFFFFFFFFF800 C0A0000000000000_00 +00000000007FFF1F 415FFFC7C0000000_00 +FFFFFE534F5676F7 C27ACB0A98909000_00 +FFFFFFFFFFFFFC00 C090000000000000_00 +0000001004FFFFFD 423004FFFFFD0000_00 +0000035C939669F1 428AE49CB34F8800_00 +FFFFFFFFFFFFFE00 C080000000000000_00 +1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFD_01 +FFFFFFFFFFFFFF91 C05BC00000000000_00 +FFFFFFFFFFFFFF00 C070000000000000_00 +01FFFFFFFBFFEFFE 437FFFFFFFBFFEFF_01 +000000000000016E 4076E00000000000_00 +FFFFFFFFFFFFFF80 C060000000000000_00 +FFF7FFFFFFFFF7FD C320000000001006_00 +FFFFF8E2BCFAC553 C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0 C050000000000000_00 +FFFFFBFFFFFE0FFE C290000007C00800_00 +00000001A4E704BF 41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0 C040000000000000_00 +1400007FFFFFFFFD 43B400007FFFFFFF_01 +FFFFFFFC93B187B4 C20B6273C2600000_00 +FFFFFFFFFFFFFFF0 C030000000000000_00 +40000000007FFFFD 43D0000000001FFF_01 +000000000067D468 4159F51A00000000_00 +FFFFFFFFFFFFFFF8 C020000000000000_00 +007FFEFFFFFBFFFE 435FFFBFFFFEFFFF_01 +FFFFFFE26CEC79F8 C23D931386080000_00 +FFFFFFFFFFFFFFFC C010000000000000_00 +00FFFFFF000000FF 436FFFFFE000001F_01 +FFFFFFFFE0D3983A C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE C000000000000000_00 +00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF BFF0000000000000_00 +000008000000027E 42A000000004FC00_00 +000000000000F4E8 40EE9D0000000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFF83FFDF C15F000840000000_00 +00000E11407887B2 42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +04000003FFFFFFF6 439000000FFFFFFF_01 +0000000000000513 40944C0000000000_00 +FFFFFFFFFFFFFFF7 C022000000000000_00 +BFFC00000000003E C3D000FFFFFFFFFF_01 +00000008D7BBB75B 4221AF776EB60000_00 +FFFFFFFFFFFFFFEF C031000000000000_00 +000FFFFBFFFC0000 432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23 C14952EE80000000_00 +FFFFFFFFFFFFFFDF C040800000000000_00 +FFBFDFFFBFFFFFFF C350080010000000_01 +000000000000007F 405FC00000000000_00 +FFFFFFFFFFFFFFBF C050400000000000_00 +00000007FF800003 421FFE00000C0000_00 +000000000002BB02 4105D81000000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEE7FF C0F1801000000000_00 +00264B2B9BAD0DA2 43432595CDD686D1_00 +FFFFFFFFFFFFFEFF C070100000000000_00 +0000000000100803 4130080300000000_00 +FF9B1DCB9F857D5E C359388D181EA0A8_01 +FFFFFFFFFFFFFDFF C080080000000000_00 +FFFFFFBFFFFFEFEE C250000004048000_00 +F6FD7542899C1C6F C3A205157AECC7C7_01 +FFFFFFFFFFFFFBFF C090040000000000_00 +FF800000004001FF C35FFFFFFFEFFF80_01 +0000000002BE4932 4185F24990000000_00 +FFFFFFFFFFFFF7FF C0A0020000000000_00 +00001004000FFFFE 42B004000FFFFE00_00 +FFFFFF9DAA0123E0 C258957FB7080000_00 +FFFFFFFFFFFFEFFF C0B0010000000000_00 +00000001FDFFFDFE 41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF C0C0008000000000_00 +FE0FE00000000000 C37F020000000000_00 +0779ED944A4E2779 439DE7B65129389D_01 +FFFFFFFFFFFFBFFF C0D0004000000000_00 +FBFFFE0400000000 C3900007F0000000_00 +0000010127E03666 4270127E03666000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +FFFFF0200000FFFE C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFFFFFFEFFFF C0F0001000000000_00 +FFEFFE0000080000 C33001FFFFF80000_00 +FFFFFFFFFD3354EA C1866558B0000000_00 +FFFFFFFFFFFDFFFF C100000800000000_00 +003FF0000003FFFE 434FF8000001FFFF_00 +0000006375B23F7B 4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF C110000400000000_00 +000407FFFFFFFFF6 43101FFFFFFFFFD8_00 +0000000092117F38 41E2422FE7000000_00 +FFFFFFFFFFF7FFFF C120000200000000_00 +FFFFFFFFFFFF7FFF C0E0002000000000_00 +00000000000008BE 40A17C0000000000_00 +FFFFFFFFFFEFFFFF C130000100000000_00 +004000020FFFFFFF 4350000083FFFFFF_01 +FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF C140000080000000_00 +00FFFFFFFFFFFFFD 436FFFFFFFFFFFFF_01 +00000023C2C6F284 4241E16379420000_00 +FFFFFFFFFFBFFFFF C150000040000000_00 +FFFDDFFFFFFFFFFD C301000000000018_00 +00000000746356C4 41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF C160000020000000_00 +010000000000BFFF 4370000000000BFF_01 +FFFFFFFFFFFFFFFD C008000000000000_00 +FFFFFFFFFEFFFFFF C170000010000000_00 +FFFFBF7FFBFFFFFE C2D0200100000080_00 +00000006386CE889 4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF C180000008000000_00 +F00000F7FFFFFFFF C3AFFFFE10000000_01 +FFFDFC53090C46A4 C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +0000000000800047 41600008E0000000_00 +FFFFFFFFD693872E C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF C1A0000002000000_00 +000000007FBFFBFF 41DFEFFEFFC00000_00 +00000026A7845E35 424353C22F1A8000_00 +FFFFFFFFEFFFFFFF C1B0000001000000_00 +FFFFFFDFFFFFFBFD C240000002018000_00 +000000001433D14C 41B433D14C000000_00 +FFFFFFFFDFFFFFFF C1C0000000800000_00 +0001FFFFFFE0000E 42FFFFFFFE0000E0_00 +F0F23E8068D3D84A C3AE1B82FF2E584F_01 +FFFFFFFFBFFFFFFF C1D0000000400000_00 +F7FFBFFFFFFFBFFF C3A0008000000080_01 +FFFFBD29B7459087 C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF C1E0000000200000_00 +FFFFFFF8FFFFBFFF C21C000100040000_00 +FFFFFFFFFFEDDC06 C13223FA00000000_00 +FFFFFFFEFFFFFFFF C1F0000000100000_00 +FFFFFFF80001FFFF C21FFFF800040000_00 +0000000000002FF9 40C7FC8000000000_00 +FFFFFFFDFFFFFFFF C200000000080000_00 +004000040000FFFF 4350000100003FFF_01 +FFFFFFFFFFFFFFF1 C02E000000000000_00 +FFFFFFFBFFFFFFFF C210000000040000_00 +C0000000007FFFFA C3CFFFFFFFFFC000_01 +FFFFFFFFFE053E2B C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF C220000000020000_00 +7FFE000007FFFFFF 43DFFF800001FFFF_01 +000000000000000D 402A000000000000_00 +FFFFFFEFFFFFFFFF C230000000010000_00 +F80000000001007E C39FFFFFFFFFFBFE_01 +FFFFED48424AD9D6 C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF C240000000008000_00 +FFFFFE0001FEFFFF C27FFFE010001000_00 +000000000000013B 4073B00000000000_00 +FFFFFFBFFFFFFFFF C250000000004000_00 +0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 +4A16BD4128090C83 43D285AF504A0243_01 +FFFFFF7FFFFFFFFF C260000000002000_00 +00FFF7FFFF7FFFFE 436FFEFFFFEFFFFF_01 +0000000000000006 4018000000000000_00 +FFFFFEFFFFFFFFFF C270000000001000_00 +FBFFFFBFFFBFFFFF C390000100010000_01 +00000000000001BA 407BA00000000000_00 +FFFFFDFFFFFFFFFF C280000000000800_00 +0000000040000082 41D0000020800000_00 +FF07A2BF5B689F89 C36F0BA81492EC0E_01 +FFFFFBFFFFFFFFFF C290000000000400_00 +0000001FF8000008 423FF80000080000_00 +F87CAA7DE672DE8B C39E0D5608663485_01 +FFFFF7FFFFFFFFFF C2A0000000000200_00 +07FFF80000000002 439FFFE000000000_01 +0000000010A1E5B8 41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF C2B0000000000100_00 +F7FFFFE00007FFFF C3A000003FFFF000_01 +FFFFFFFFFFF6ADFC C122A40800000000_00 +FFFFDFFFFFFFFFFF C2C0000000000080_00 +FFFFFF03FFFFFFC0 C26F800000080000_00 +EA579475948F0032 C3B5A86B8A6B70FF_01 +FFFFBFFFFFFFFFFF C2D0000000000040_00 +FC00000000003FF6 C38FFFFFFFFFFE00_01 +002E677AC313BF60 434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF C2E0000000000020_00 +02000007FF7FFFFF 438000003FFBFFFF_01 +0000000E999639F1 422D332C73E20000_00 +FFFEFFFFFFFFFFFF C2F0000000000010_00 +FFFF83FFFFFFFFBE C2DF000000001080_00 +000000000001537D 40F537D000000000_00 +FFFDFFFFFFFFFFFF C300000000000008_00 +EFFFFFC00000003D C3B000003FFFFFFF_01 +FFFFFFF21FEDFD35 C22BC02405960000_00 +FFFBFFFFFFFFFFFF C310000000000004_00 +FFFFFFF0000007FE C22FFFFFF0040000_00 +FFFFFFFFFFDE0839 C140FBE380000000_00 +FFF7FFFFFFFFFFFF C320000000000002_00 +0000007FFFE000FF 425FFFF8003FC000_00 +FFFFFFFF79F30F48 C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF C330000000000001_00 +FFFFFC13FFFFFFFD C28F600000001800_00 +0000000000001B85 40BB850000000000_00 +FFDFFFFFFFFFFFFF C340000000000000_01 +000008000007FFFE 42A000000FFFFC00_00 +12DB4409E5AE87E6 43B2DB4409E5AE87_01 +FFBFFFFFFFFFFFFF C350000000000000_01 +FFFFFFFFFFF7BFEE C120802400000000_00 +FFFFFFFFFFFFFFFD C008000000000000_00 +FF7FFFFFFFFFFFFF C360000000000000_01 +000000001040FFFE 41B040FFFE000000_00 +00000909A09C13D3 42A213413827A600_00 +FEFFFFFFFFFFFFFF C370000000000000_01 +FFFFFF01FFFFFF7F C26FC00000102000_00 +FFFFFF72E7D2575D C261A305B5146000_00 +FDFFFFFFFFFFFFFF C380000000000000_01 +FFFFFFFFFFFEFFDB C0F0025000000000_00 +0000000000000017 4037000000000000_00 +FBFFFFFFFFFFFFFF C390000000000000_01 +100000001FFFFFF6 43B00000001FFFFF_01 +000000114B12EF51 42314B12EF510000_00 +F7FFFFFFFFFFFFFF C3A0000000000000_01 +0407FFFFFFFFFEFF 43901FFFFFFFFFFB_01 +FFFFFF769F3A5C2C C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF C3B0000000000000_01 +FFFFFFFDF7FFFFFD C200400000180000_00 +FFFFFFFFFFFFFFF2 C02C000000000000_00 +DFFFFFFFFFFFFFFF C3C0000000000000_01 +FFFFFFFFFE0007FF C17FFF8010000000_00 +000000000000001E 403E000000000000_00 +BFFFFFFFFFFFFFFF C3D0000000000000_01 +FFF800000009FFFF C31FFFFFFFD80004_00 +0000000000007AA4 40DEA90000000000_00 +7FFFFFFFFFFFFFFF 43DFFFFFFFFFFFFF_01 +4080000000FFFFFF 43D0200000003FFF_01 +000000000DE7601D 41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF 43CFFFFFFFFFFFFF_01 +FFCFFFFFFFBFFFFE C348000000200001_00 +FFFFFFFFFFFFFFCA C04B000000000000_00 +1FFFFFFFFFFFFFFF 43BFFFFFFFFFFFFF_01 +000080400000003F 42E00800000007E0_00 +00000000001F75A5 413F75A500000000_00 +0FFFFFFFFFFFFFFF 43AFFFFFFFFFFFFF_01 +FFFFFFEFFFFFCFFE C230000030020000_00 +FFFFFEE775887420 C27188A778BE0000_00 +07FFFFFFFFFFFFFF 439FFFFFFFFFFFFF_01 +00000000000801FE 412003FC00000000_00 +0000000000213FF1 41409FF880000000_00 +03FFFFFFFFFFFFFF 438FFFFFFFFFFFFF_01 +07FEFFFFFFFFFFEE 439FFBFFFFFFFFFF_01 +0000000000000004 4010000000000000_00 +01FFFFFFFFFFFFFF 437FFFFFFFFFFFFF_01 +0000000820000003 4220400000060000_00 +FFFFFFF9AD105214 C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF 436FFFFFFFFFFFFF_01 +FFFFF00FFFFFFFBE C2AFE00000008400_00 +FFFFFFFFFFCC48E7 C149DB8C80000000_00 +007FFFFFFFFFFFFF 435FFFFFFFFFFFFF_01 +00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB C16E8B26A0000000_00 +003FFFFFFFFFFFFF 434FFFFFFFFFFFFF_01 +FFFFFF7FBFFFFFBF C260080000082000_00 +FFFFFFFFFFF24425 C12B77B600000000_00 +001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 +200000001FFBFFFF 43C00000000FFDFF_01 +FFFFFF4E7115EC53 C26631DD4275A000_00 +000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF C29FF00000010400_00 +FFFFFC2E539ADCFE C28E8D6329181000_00 +0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF C190000004000000_00 +00000055084732F3 42554211CCBCC000_00 +0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00 C3D0002000000000_01 +FFFFFFFFFFFF8543 C0DEAF4000000000_00 +0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 +0000001FFBFFE000 423FFBFFE0000000_00 +FFFFFFFFFFFE491B C0FB6E5000000000_00 +0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 +FC00200000001FFE C38FFEFFFFFFFF00_01 +FFFFF16898822A24 C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE 43CFFF81FFFFFFFF_01 +FFFFFF8FFE18C7BF C25C0079CE104000_00 +00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD C270001000003000_00 +00F03620C1266ED9 436E06C41824CDDB_01 +00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF C3D0204000000000_01 +FFFFFFFFFFFFFFD5 C045800000000000_00 +00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE C31000001FF00008_00 +0000000000068684 411A1A1000000000_00 +000007FFFFFFFFFF 429FFFFFFFFFFC00_00 +DFFFFFE00000001E C3C000000FFFFFFF_01 +FFFFFFFFFFFFECF5 C0B30B0000000000_00 +000003FFFFFFFFFF 428FFFFFFFFFF800_00 +FFFF00400000FFFF C2EFF7FFFFE00020_00 +0000000000000002 4000000000000000_00 +000001FFFFFFFFFF 427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE C390000000000108_01 +0000000000000BC9 40A7920000000000_00 +000000FFFFFFFFFF 426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE C3DFE00000000008_01 +FFC274E35A70CD76 C34EC58E52C79945_00 +0000007FFFFFFFFF 425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD 43AFFFFFFFFDFFFF_01 +FFFFFFFF00E73AFC C1EFE318A0800000_00 +0000003FFFFFFFFF 424FFFFFFFFF8000_00 +FFC000000001000E C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9 C0FEA17000000000_00 +0000001FFFFFFFFF 423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 +0000000000000033 4049800000000000_00 +0000000FFFFFFFFF 422FFFFFFFFE0000_00 +000000001FFFBFFF 41BFFFBFFF000000_00 +FFFFFFEE6B141E1B C23194EBE1E50000_00 +00000007FFFFFFFF 421FFFFFFFFC0000_00 +FFFFFFFFF60007FF C1A3FFF002000000_00 +00000001AB310BA6 41FAB310BA600000_00 +00000003FFFFFFFF 420FFFFFFFF80000_00 +0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195 C0ACD60000000000_00 +00000001FFFFFFFF 41FFFFFFFFF00000_00 +FFFFFFFF8000000B C1DFFFFFFD400000_00 +00000019BA8D5559 4239BA8D55590000_00 +00000000FFFFFFFF 41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9 C390040000000000_01 +FFFFFFB6F062822D C25243E75F74C000_00 +000000007FFFFFFF 41DFFFFFFFC00000_00 +0001000000000082 42F0000000000820_00 +01CEAD9E2FB104A4 437CEAD9E2FB104A_01 +000000003FFFFFFF 41CFFFFFFF800000_00 +000003FFFFFFFF7C 428FFFFFFFFBE000_00 +FFFFFFFFFD681E78 C184BF0C40000000_00 +000000001FFFFFFF 41BFFFFFFF000000_00 +00002000400001FF 42C000200000FF80_00 +0000000000000018 4038000000000000_00 +000000000FFFFFFF 41AFFFFFFE000000_00 +3FFF80000000003E 43CFFFC000000000_01 +FFFFFFFFFFFFFF95 C05AC00000000000_00 +0000000007FFFFFF 419FFFFFFC000000_00 +010000BFFFFFFFFF 4370000BFFFFFFFF_01 +0000001697087B19 423697087B190000_00 +0000000003FFFFFF 418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD C390000000004400_01 +0000000E64BDFC55 422CC97BF8AA0000_00 +0000000001FFFFFF 417FFFFFF0000000_00 +FC00000001FFFFFE C38FFFFFFFF00000_01 +FFFED156A62AB849 C2F2EA959D547B70_00 +0000000000FFFFFF 416FFFFFE0000000_00 +FFFFFFF83FEFFFFD C21F0040000C0000_00 +00015354EAE7C259 42F5354EAE7C2590_00 +00000000007FFFFF 415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F C060200000000000_00 +FFFFFFF0F4DF3C75 C22E164187160000_00 +00000000003FFFFF 414FFFFF80000000_00 +FFFA000000001FFF C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000001FFFFF 413FFFFF00000000_00 +FFFFFFFFFF7FFE40 C160003800000000_00 +FFFFFFDB5433CB9B C24255E61A328000_00 +00000000000FFFFF 412FFFFE00000000_00 +FFFFFDFFDFFDFFFD C280010010001800_00 +FFFFFFFFFFDEAE1F C140A8F080000000_00 +000000000007FFFF 411FFFFC00000000_00 +FFFFFFFFF0080006 C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7 C1F88CA213900000_00 +000000000003FFFF 410FFFF800000000_00 +00000001FBFFFFFF 41FFBFFFFFF00000_00 +000003757D8B12ED 428BABEC58976800_00 +000000000001FFFF 40FFFFF000000000_00 +FFFFFE07F7FFFFFF C27F808000001000_00 +00000A654064E046 42A4CA80C9C08C00_00 +000000000000FFFF 40EFFFE000000000_00 +08000000000017FF 43A000000000002F_01 +FFFFFFFFFFFFFFE7 C039000000000000_00 +0000000000007FFF 40DFFFC000000000_00 +07FFFFFFFFFFFDF6 439FFFFFFFFFFFF7_01 +FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 +0000000000003FFF 40CFFF8000000000_00 +0000300004000000 42C8000200000000_00 +FFFFFFF70B77F34F C221E91019620000_00 +0000000000001FFF 40BFFF0000000000_00 +FFFFFF80006FFFFE C25FFFE400008000_00 +0000013EB4D67EC8 4273EB4D67EC8000_00 +0000000000000FFF 40AFFE0000000000_00 +BFFFDFFFFBFFFFFF C3D0000800010000_01 +0005CEAF34EA1DC7 43173ABCD3A8771C_00 +00000000000007FF 409FFC0000000000_00 +00004800007FFFFD 42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB C014000000000000_00 +00000000000003FF 408FF80000000000_00 +0000000200001000 4200000080000000_00 +00000000000360D0 410B068000000000_00 +00000000000001FF 407FF00000000000_00 +01003FFFFFFFFFFC 437003FFFFFFFFFF_01 +00C000708FF1BA51 4368000E11FE374A_01 +00000000000000FF 406FE00000000000_00 +F802000003FFFFFF C39FF7FFFFF00000_01 +0F9E07DCC0BDC061 43AF3C0FB9817B80_01 +000000000000007F 405FC00000000000_00 +03FF0000000000FF 438FF80000000007_01 +FFFFFFE1B9B2A079 C23E464D5F870000_00 +000000000000003F 404F800000000000_00 +FFF80000000080FF C31FFFFFFFFDFC04_00 +00000000001EB5B4 413EB5B400000000_00 +000000000000001F 403F000000000000_00 +000000000077FBFE 415DFEFF80000000_00 +00000000005AC607 4156B181C0000000_00 +000000000000000F 402E000000000000_00 +FFFFFFFEF80000FF C1F07FFFF0100000_00 +000005C5B9D66984 429716E759A61000_00 +0000000000000007 401C000000000000_00 +C001FFFFFFF00000 C3CFFF0000000800_00 +00001D06B372AA06 42BD06B372AA0600_00 +0000000000000003 4008000000000000_00 From 91d9b6800bd240967b0c15b7160853088f469d29 Mon Sep 17 00:00:00 2001 From: bbracker Date: Wed, 6 Oct 2021 16:55:38 -0400 Subject: [PATCH 012/118] update linker scripts to look for vmlinux files --- wally-pipelined/linux-testgen/linux-testvectors/tvLinker.sh | 3 +++ wally-pipelined/linux-testgen/linux-testvectors/tvUnlinker.sh | 3 +++ 2 files changed, 6 insertions(+) diff --git a/wally-pipelined/linux-testgen/linux-testvectors/tvLinker.sh b/wally-pipelined/linux-testgen/linux-testvectors/tvLinker.sh index f694b112a..70ef47109 100755 --- a/wally-pipelined/linux-testgen/linux-testvectors/tvLinker.sh +++ b/wally-pipelined/linux-testgen/linux-testvectors/tvLinker.sh @@ -2,4 +2,7 @@ echo "Warning: this script will only work if your repo is on Tera" ln -s /courses/e190ax/buildroot_boot/all.txt all.txt ln -s /courses/e190ax/buildroot_boot/bootmem.txt bootmem.txt ln -s /courses/e190ax/buildroot_boot/ram.txt ram.txt +ln -s /courses/e190ax/buildroot_boot/vmlinux.objdump vmlinux.objdump +ln -s /courses/e190ax/buildroot_boot/vmlinux.objdump.addr vmlinux.objdump.addr +ln -s /courses/e190ax/buildroot_boot/vmlinux.objdump.lab vmlinux.objdump.lab echo "Done!" diff --git a/wally-pipelined/linux-testgen/linux-testvectors/tvUnlinker.sh b/wally-pipelined/linux-testgen/linux-testvectors/tvUnlinker.sh index bded8a16e..acf155c00 100755 --- a/wally-pipelined/linux-testgen/linux-testvectors/tvUnlinker.sh +++ b/wally-pipelined/linux-testgen/linux-testvectors/tvUnlinker.sh @@ -3,4 +3,7 @@ unlink all.txt unlink bootmem.txt unlink ram.txt +unlink vmlinux.objdump +unlink vmlinux.objdump.addr +unlink vmlinux.objdump.lab echo "Done!" From 28e147bb1969897b3114f37e20459e90bb263439 Mon Sep 17 00:00:00 2001 From: "James E. Stine" Date: Thu, 7 Oct 2021 15:14:54 -0500 Subject: [PATCH 013/118] update scripts --- wally-pipelined/testbench/fp/README.md | 115 ++ .../testbench/fp/create_vectors32_64.csh | 11 + .../testbench/fp/create_vectors64_32.csh | 13 + .../testbench/fp/create_vectorsi.csh | 18 + wally-pipelined/testbench/fp/i32_f32_rd.tv | 744 ++++---- wally-pipelined/testbench/fp/i32_f32_rne.tv | 744 ++++---- wally-pipelined/testbench/fp/i32_f32_ru.tv | 744 ++++---- wally-pipelined/testbench/fp/i32_f32_rz.tv | 744 ++++---- wally-pipelined/testbench/fp/i32_f64_rd.tv | 744 ++++---- wally-pipelined/testbench/fp/i32_f64_rne.tv | 744 ++++---- wally-pipelined/testbench/fp/i32_f64_ru.tv | 744 ++++---- wally-pipelined/testbench/fp/i32_f64_rz.tv | 744 ++++---- wally-pipelined/testbench/fp/i64_f32_rd.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/i64_f32_rne.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/i64_f32_ru.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/i64_f32_rz.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/i64_f64_rd.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/i64_f64_rne.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/i64_f64_ru.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/i64_f64_rz.tv | 1512 ++++++++--------- wally-pipelined/testbench/fp/ui32_f32_rd.tv | 372 ++++ wally-pipelined/testbench/fp/ui32_f32_rne.tv | 372 ++++ wally-pipelined/testbench/fp/ui32_f32_ru.tv | 372 ++++ wally-pipelined/testbench/fp/ui32_f32_rz.tv | 372 ++++ wally-pipelined/testbench/fp/ui32_f64_rd.tv | 372 ++++ wally-pipelined/testbench/fp/ui32_f64_rne.tv | 372 ++++ wally-pipelined/testbench/fp/ui32_f64_ru.tv | 372 ++++ wally-pipelined/testbench/fp/ui32_f64_rz.tv | 372 ++++ wally-pipelined/testbench/fp/ui64_f32_rd.tv | 756 +++++++++ wally-pipelined/testbench/fp/ui64_f32_rne.tv | 756 +++++++++ wally-pipelined/testbench/fp/ui64_f32_ru.tv | 756 +++++++++ wally-pipelined/testbench/fp/ui64_f32_rz.tv | 756 +++++++++ wally-pipelined/testbench/fp/ui64_f64_rd.tv | 756 +++++++++ wally-pipelined/testbench/fp/ui64_f64_rne.tv | 756 +++++++++ wally-pipelined/testbench/fp/ui64_f64_ru.tv | 756 +++++++++ wally-pipelined/testbench/fp/ui64_f64_rz.tv | 756 +++++++++ wally-pipelined/testbench/fp/undy.sh | 2 + 37 files changed, 18207 insertions(+), 9024 deletions(-) create mode 100644 wally-pipelined/testbench/fp/README.md create mode 100644 wally-pipelined/testbench/fp/ui32_f32_rd.tv create mode 100644 wally-pipelined/testbench/fp/ui32_f32_rne.tv create mode 100644 wally-pipelined/testbench/fp/ui32_f32_ru.tv create mode 100644 wally-pipelined/testbench/fp/ui32_f32_rz.tv create mode 100644 wally-pipelined/testbench/fp/ui32_f64_rd.tv create mode 100644 wally-pipelined/testbench/fp/ui32_f64_rne.tv create mode 100644 wally-pipelined/testbench/fp/ui32_f64_ru.tv create mode 100644 wally-pipelined/testbench/fp/ui32_f64_rz.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f32_rd.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f32_rne.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f32_ru.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f32_rz.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f64_rd.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f64_rne.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f64_ru.tv create mode 100644 wally-pipelined/testbench/fp/ui64_f64_rz.tv create mode 100755 wally-pipelined/testbench/fp/undy.sh diff --git a/wally-pipelined/testbench/fp/README.md b/wally-pipelined/testbench/fp/README.md new file mode 100644 index 000000000..f8dcfeb63 --- /dev/null +++ b/wally-pipelined/testbench/fp/README.md @@ -0,0 +1,115 @@ +These are the testvectors (TV) to test the floating-point units using +Berkeley TestFloat written originally by John Hauser. TestFloat +requires both TestFloat and SoftFloat. + +The locations at time of this README is found here: +TestFloat-3e: http://www.jhauser.us/arithmetic/TestFloat.html +SoftFloat-3e: http://www.jhauser.us/arithmetic/SoftFloat.html + +These files have been compiled on a x86_64 environment by going into +the build/Linux-x86_64-GCC directory and typing make. A script +createX.sh (e.g., create_vectors32.sh) has been included that create +the TV for each rounding mode and operation. These scripts must be +run in the build directory of TestFloat. + +After each TV has been created a script (included) is run called +undy.sh that puts an underscore between vector to allow SystemVerilog +readmemh to read correctly. + +./undy.sh file.tv + +To remove all the underscores from all the TV files, one can run the +command that will add underscores appropriately to all the files. + +sed -i 's/ /_/g' *.tv + +Note: due to size, the fxx_fma_xx.tv vectors are not included. +However, they can easily be created with the create scripts. + +James Stine +10/7/2021 + + +File Sizes + 600 1800 17400 f32_f64_rd.tv + 600 1800 17400 f32_f64_rne.tv + 600 1800 17400 f32_f64_ru.tv + 600 1800 17400 f32_f64_rz.tv + 600 1800 17400 f32_i64_rd.tv + 600 1800 17400 f32_i64_rne.tv + 600 1800 17400 f32_i64_ru.tv + 600 1800 17400 f32_i64_rz.tv + 600 1800 17400 f32_ui64_rd.tv + 600 1800 17400 f32_ui64_rne.tv + 600 1800 17400 f32_ui64_ru.tv + 600 1800 17400 f32_ui64_rz.tv + 46464 185856 2509056 f64_add_rd.tv + 46464 185856 2509056 f64_add_rne.tv + 46464 185856 2509056 f64_add_ru.tv + 46464 185856 2509056 f64_add_rz.tv + 46464 185856 2509056 f64_div_rd.tv + 46464 185856 2509056 f64_div_rne.tv + 46464 185856 2509056 f64_div_ru.tv + 46464 185856 2509056 f64_div_rz.tv + 768 2304 22272 f64_f32_rd.tv + 768 2304 22272 f64_f32_rne.tv + 768 2304 22272 f64_f32_ru.tv + 768 2304 22272 f64_f32_rz.tv + 6133248 30666240 435460608 f64_fma_rd.tv + 6133248 30666240 435460608 f64_fma_rne.tv + 6133248 30666240 435460608 f64_fma_ru.tv + 6133248 30666240 435460608 f64_fma_rz.tv + 768 2304 22272 f64_i32_rd.tv + 768 2304 22272 f64_i32_rne.tv + 768 2304 22272 f64_i32_ru.tv + 768 2304 22272 f64_i32_rz.tv + 46464 185856 2509056 f64_mul_rd.tv + 46464 185856 2509056 f64_mul_rne.tv + 46464 185856 2509056 f64_mul_ru.tv + 46464 185856 2509056 f64_mul_rz.tv + 768 2304 28416 f64_sqrt_rd.tv + 768 2304 28416 f64_sqrt_rne.tv + 768 2304 28416 f64_sqrt_ru.tv + 768 2304 28416 f64_sqrt_rz.tv + 46464 185856 2509056 f64_sub_rd.tv + 46464 185856 2509056 f64_sub_rne.tv + 46464 185856 2509056 f64_sub_ru.tv + 46464 185856 2509056 f64_sub_rz.tv + 768 2304 22272 f64_ui32_rd.tv + 768 2304 22272 f64_ui32_rne.tv + 768 2304 22272 f64_ui32_ru.tv + 768 2304 22272 f64_ui32_rz.tv + 372 1116 7812 i32_f32_rd.tv + 372 1116 7812 i32_f32_rne.tv + 372 1116 7812 i32_f32_ru.tv + 372 1116 7812 i32_f32_rz.tv + 372 1116 10788 i32_f64_rd.tv + 372 1116 10788 i32_f64_rne.tv + 372 1116 10788 i32_f64_ru.tv + 372 1116 10788 i32_f64_rz.tv + 756 2268 21924 i64_f32_rd.tv + 756 2268 21924 i64_f32_rne.tv + 756 2268 21924 i64_f32_ru.tv + 756 2268 21924 i64_f32_rz.tv + 756 2268 27972 i64_f64_rd.tv + 756 2268 27972 i64_f64_rne.tv + 756 2268 27972 i64_f64_ru.tv + 756 2268 27972 i64_f64_rz.tv + 372 1116 7812 ui32_f32_rd.tv + 372 1116 7812 ui32_f32_rne.tv + 372 1116 7812 ui32_f32_ru.tv + 372 1116 7812 ui32_f32_rz.tv + 372 1116 10788 ui32_f64_rd.tv + 372 1116 10788 ui32_f64_rne.tv + 372 1116 10788 ui32_f64_ru.tv + 372 1116 10788 ui32_f64_rz.tv + 756 2268 21924 ui64_f32_rd.tv + 756 2268 21924 ui64_f32_rne.tv + 756 2268 21924 ui64_f32_ru.tv + 756 2268 21924 ui64_f32_rz.tv + 756 2268 27972 ui64_f64_rd.tv + 756 2268 27972 ui64_f64_rne.tv + 756 2268 27972 ui64_f64_ru.tv + 756 2268 27972 ui64_f64_rz.tv + 25313952 125751264 1783125024 total + diff --git a/wally-pipelined/testbench/fp/create_vectors32_64.csh b/wally-pipelined/testbench/fp/create_vectors32_64.csh index 13f4c7bed..63ba70d13 100755 --- a/wally-pipelined/testbench/fp/create_vectors32_64.csh +++ b/wally-pipelined/testbench/fp/create_vectors32_64.csh @@ -3,3 +3,14 @@ ./testfloat_gen -rminMag f32_to_f64 > f32_f64_rz.tv ./testfloat_gen -rmax f32_to_f64 > f32_f64_ru.tv ./testfloat_gen -rmin f32_to_f64 > f32_f64_rd.tv + +./testfloat_gen -rnear_even f32_to_i64 > f32_i64_rne.tv +./testfloat_gen -rminMag f32_to_i64 > f32_i64_rz.tv +./testfloat_gen -rmax f32_to_i64 > f32_i64_ru.tv +./testfloat_gen -rmin f32_to_i64 > f32_i64_rd.tv + +./testfloat_gen -rnear_even f32_to_ui64 > f32_ui64_rne.tv +./testfloat_gen -rminMag f32_to_ui64 > f32_ui64_rz.tv +./testfloat_gen -rmax f32_to_ui64 > f32_ui64_ru.tv +./testfloat_gen -rmin f32_to_ui64 > f32_ui64_rd.tv + diff --git a/wally-pipelined/testbench/fp/create_vectors64_32.csh b/wally-pipelined/testbench/fp/create_vectors64_32.csh index 3448d9c42..45f054054 100755 --- a/wally-pipelined/testbench/fp/create_vectors64_32.csh +++ b/wally-pipelined/testbench/fp/create_vectors64_32.csh @@ -3,3 +3,16 @@ ./testfloat_gen -rminMag f64_to_f32 > f64_f32_rz.tv ./testfloat_gen -rmax f64_to_f32 > f64_f32_ru.tv ./testfloat_gen -rmin f64_to_f32 > f64_f32_rd.tv + +./testfloat_gen -rnear_even f64_to_i32 > f64_i32_rne.tv +./testfloat_gen -rminMag f64_to_i32 > f64_i32_rz.tv +./testfloat_gen -rmax f64_to_i32 > f64_i32_ru.tv +./testfloat_gen -rmin f64_to_i32 > f64_i32_rd.tv + +./testfloat_gen -rnear_even f64_to_ui32 > f64_ui32_rne.tv +./testfloat_gen -rminMag f64_to_ui32 > f64_ui32_rz.tv +./testfloat_gen -rmax f64_to_ui32 > f64_ui32_ru.tv +./testfloat_gen -rmin f64_to_ui32 > f64_ui32_rd.tv + + + diff --git a/wally-pipelined/testbench/fp/create_vectorsi.csh b/wally-pipelined/testbench/fp/create_vectorsi.csh index 7a342e9fa..f6c249839 100755 --- a/wally-pipelined/testbench/fp/create_vectorsi.csh +++ b/wally-pipelined/testbench/fp/create_vectorsi.csh @@ -19,5 +19,23 @@ ./testfloat_gen -rmax -i64_to_f32 > i64_f32_ru.tv ./testfloat_gen -rmin -i64_to_f32 > i64_f32_rd.tv +./testfloat_gen -rnear_even -ui32_to_f64 > ui32_f64_rne.tv +./testfloat_gen -rminMag -ui32_to_f64 > ui32_f64_rz.tv +./testfloat_gen -rmax -ui32_to_f64 > ui32_f64_ru.tv +./testfloat_gen -rmin -ui32_to_f64 > ui32_f64_rd.tv +./testfloat_gen -rnear_even -ui64_to_f64 > ui64_f64_rne.tv +./testfloat_gen -rminMag -ui64_to_f64 > ui64_f64_rz.tv +./testfloat_gen -rmax -ui64_to_f64 > ui64_f64_ru.tv +./testfloat_gen -rmin -ui64_to_f64 > ui64_f64_rd.tv + +./testfloat_gen -rnear_even -ui32_to_f32 > ui32_f32_rne.tv +./testfloat_gen -rminMag -ui32_to_f32 > ui32_f32_rz.tv +./testfloat_gen -rmax -ui32_to_f32 > ui32_f32_ru.tv +./testfloat_gen -rmin -ui32_to_f32 > ui32_f32_rd.tv + +./testfloat_gen -rnear_even -ui64_to_f32 > ui64_f32_rne.tv +./testfloat_gen -rminMag -ui64_to_f32 > ui64_f32_rz.tv +./testfloat_gen -rmax -ui64_to_f32 > ui64_f32_ru.tv +./testfloat_gen -rmin -ui64_to_f32 > ui64_f32_rd.tv diff --git a/wally-pipelined/testbench/fp/i32_f32_rd.tv b/wally-pipelined/testbench/fp/i32_f32_rd.tv index e065d28ac..816f83ef2 100644 --- a/wally-pipelined/testbench/fp/i32_f32_rd.tv +++ b/wally-pipelined/testbench/fp/i32_f32_rd.tv @@ -1,372 +1,372 @@ -1FEFFFEF 4DFF7FFF_01 -FFFFC48E C66DC800_00 -00000000 00000000_00 -007FFFCD 4AFFFF9A_00 -00009E14 471E1400_00 -00000001 3F800000_00 -001FFFFB 49FFFFD8_00 -FFFFDE38 C6072000_00 -00000002 40000000_00 -FFDFFC02 CA000FF8_00 -FB794C79 CC90D671_01 -00000004 40800000_00 -F00FFFFE CD7F0001_01 -00000A95 45295000_00 -00000008 41000000_00 -FFFFF97F C4D02000_00 -FFAE458D CAA374E6_00 -00000010 41800000_00 -0101001E 4B80800F_00 -29EB4561 4E27AD15_01 -00000020 42000000_00 -8001FFEE CEFFFC01_01 -FFFBDD08 C8845F00_00 -00000040 42800000_00 -FFF03FF9 C97C0070_00 -FFCEDF36 CA448328_00 -00000080 43000000_00 -0000F01F 47701F00_00 -00000279 441E4000_00 -00000100 43800000_00 -BFFFFFEF CE800001_01 -00000007 40E00000_00 -00000200 44000000_00 -010BFFFD 4B85FFFE_01 -FFFFF590 C5270000_00 -00000400 44800000_00 -F7FFFEFB CD000011_01 -2FEA335F 4E3FA8CD_01 -00000800 45000000_00 -FFC07FFF CA7E0004_00 -177957FD 4DBBCABF_01 -00001000 45800000_00 -01FBFFEE 4BFDFFF7_00 -FFFFFAC9 C4A6E000_00 -00002000 46000000_00 -FFFF8004 C6FFF800_00 -FFFBE0DE C883E440_00 -00004000 46800000_00 -3F00001E 4E7C0000_01 -00000000 00000000_00 -00008000 47000000_00 -FF8201FF CAFBFC02_00 -FFFFD2F1 C6343C00_00 -00010000 47800000_00 -0000047E 448FC000_00 -0011B7E5 498DBF28_00 -00020000 48000000_00 -02200200 4C080080_00 -0013F7E6 499FBF30_00 -00040000 48800000_00 -FFFDC007 C80FFE40_00 -FD0ABD9A CC3D509A_01 -00080000 49000000_00 -0000607F 46C0FE00_00 -00003CEE 4673B800_00 -00100000 49800000_00 -DFDFE000 CE008080_00 -FFFB1642 C89D37C0_00 -00200000 4A000000_00 -FC000078 CC7FFFE2_00 -5F70EEC1 4EBEE1DD_01 -00400000 4A800000_00 -00100082 49800410_00 -FFFFFE21 C3EF8000_00 -00800000 4B000000_00 -FF7BFF7F CB040081_00 -FFFF6393 C71C6D00_00 -01000000 4B800000_00 -07EFFEFD 4CFDFFDF_01 -FFFFFDB4 C4130000_00 -02000000 4C000000_00 -8002FFFF CEFFFA01_01 -FFFFC8E2 C65C7800_00 -04000000 4C800000_00 -FFFC0DFE C87C8080_00 -FFFFFF1B C3650000_00 -08000000 4D000000_00 -03FFFDBF 4C7FFF6F_01 -0001092B 47849580_00 -10000000 4D800000_00 -007FBFFD 4AFF7FFA_00 -00B4F3D1 4B34F3D1_00 -20000000 4E000000_00 -FEF801FF CB83FF01_01 -00000005 40A00000_00 -40000000 4E800000_00 -BFF3FFFE CE801801_01 -0001806B 47C03580_00 -80000000 CF000000_00 -0000A07E 47207E00_00 -FFFFA59F C6B4C200_00 -C0000000 CE800000_00 -E0007FDE CDFFFC02_01 -FFF8343E C8F97840_00 -E0000000 CE000000_00 -0000FF7C 477F7C00_00 -FFFFFFF7 C1100000_00 -F0000000 CD800000_00 -BDFFFFFC CE840001_01 -FFFFE3C1 C5E1F800_00 -F8000000 CD000000_00 -28003FFE 4E2000FF_01 -00000000 00000000_00 -FC000000 CC800000_00 -00EEFFFF 4B6EFFFF_00 -00003EB0 467AC000_00 -FE000000 CC000000_00 -00000F7D 4577D000_00 -FFFFFF0F C3710000_00 -FF000000 CB800000_00 -0000406D 4680DA00_00 -0000001A 41D00000_00 -FF800000 CB000000_00 -203FFFFD 4E00FFFF_01 -0000000A 41200000_00 -FFC00000 CA800000_00 -FFFF007C C77F8400_00 -0000009B 431B0000_00 -FFE00000 CA000000_00 -00E00FFF 4B600FFF_00 -00000006 40C00000_00 -FFF00000 C9800000_00 -00200FFC 4A003FF0_00 -00000714 44E28000_00 -FFF80000 C9000000_00 -F800040E CCFFFF7F_01 -00000013 41980000_00 -FFFC0000 C8800000_00 -F83BFFFF CCF88001_01 -FFF3F584 C940A7C0_00 -FFFE0000 C8000000_00 -F6FFFBFF CD100041_01 -FFFFFFF0 C1800000_00 -FFFF0000 C7800000_00 -80003FFD CEFFFF81_01 -FFFFFFAD C2A60000_00 -FFFF8000 C7000000_00 -004001FD 4A8003FA_00 -000D734E 495734E0_00 -FFFFC000 C6800000_00 -006003FE 4AC007FC_00 -FF9DBAA8 CAC48AB0_00 -FFFFE000 C6000000_00 -000403EE 48807DC0_00 -00734668 4AE68CD0_00 -FFFFF000 C5800000_00 -01200002 4B900001_00 -FF8874A5 CAEF16B6_00 -FFFFF800 C5000000_00 -00060001 48C00020_00 -FFFFFFF8 C1000000_00 -FFFFFC00 C4800000_00 -001FFEDD 49FFF6E8_00 -FFFC56DF C86A4840_00 -FFFFFE00 C4000000_00 -EFFFEFFD CD800081_01 -FECF5EC6 CB98509D_00 -FFFFFF00 C3800000_00 -1FF00002 4DFF8000_01 -F6DB786B CD12487A_01 -FFFFFF80 C3000000_00 -F0000FBE CD7FFF05_01 -00000009 41100000_00 -FFFFFFC0 C2800000_00 -0010801F 498400F8_00 -0001F238 47F91C00_00 -FFFFFFE0 C2000000_00 -F8000047 CCFFFFF8_01 -0002133C 4804CF00_00 -FFFFFFF0 C1800000_00 -003C001F 4A70007C_00 -000001F1 43F88000_00 -FFFFFFF8 C1000000_00 -FFDFBFFF CA010004_00 -FF5E507F CB21AF81_00 -FFFFFFFC C0800000_00 -037FFFDE 4C5FFFF7_01 -FFFD7C6F C820E440_00 -FFFFFFFE C0000000_00 -000000FD 437D0000_00 -FFFFF42A C53D6000_00 -FFFFFFFF BF800000_00 -021FFF7D 4C07FFDF_01 -0000000A 41200000_00 -FFFFFFFD C0400000_00 -4010FFFF 4E8021FF_01 -FFFFFFD3 C2340000_00 -FFFFFFFB C0A00000_00 -FFFF800B C6FFEA00_00 -000000B8 43380000_00 -FFFFFFF7 C1100000_00 -FF800803 CAFFEFFA_00 -FFFFFFFE C0000000_00 -FFFFFFEF C1880000_00 -00803FFB 4B003FFB_00 -00000308 44420000_00 -FFFFFFDF C2040000_00 -2107FFFE 4E041FFF_01 -FFE15D4F C9F51588_00 -FFFFFFBF C2820000_00 -400087FD 4E80010F_01 -0000000F 41700000_00 -FFFFFF7F C3010000_00 -FDFC007E CC00FFE1_01 -00000006 40C00000_00 -FFFFFEFF C3808000_00 -FFF80100 C8FFE000_00 -FFFFFE99 C3B38000_00 -FFFFFDFF C4004000_00 -03000002 4C400000_01 -FFF716EA C90E9160_00 -FFFFFBFF C4802000_00 -C7FDFFFF CE600801_01 -FFFFE327 C5E6C800_00 -FFFFF7FF C5001000_00 -0103DFFE 4B81EFFF_00 -07661FD8 4CECC3FB_00 -FFFFEFFF C5800800_00 -83FFFFFE CEF80001_01 -FCD956DB CC49AA4A_01 -FFFFDFFF C6000400_00 -FF2001FD CB5FFE03_00 -E4D35BBF CDD96523_01 -FFFFBFFF C6800200_00 -DFEFEFFE CE004041_01 -05DA4300 4CBB4860_00 -FFFF7FFF C7000100_00 -40001040 4E800020_01 -812EDF40 CEFDA242_01 -FFFEFFFF C7800080_00 -FFFFC007 C67FE400_00 -00B6FCC9 4B36FCC9_00 -FFFDFFFF C8000040_00 -000007FE 44FFC000_00 -FC3DE950 CC7085AC_00 -FFFBFFFF C8800020_00 -7FFFFE03 4EFFFFFC_01 -FEB02B59 CBA7EA54_01 -FFF7FFFF C9000010_00 -10FF7FFF 4D87FBFF_01 -00008D5E 470D5E00_00 -FFEFFFFF C9800008_00 -FFFF007E C77F8200_00 -001C2108 49E10840_00 -FFDFFFFF CA000004_00 -00FFC001 4B7FC001_00 -F01C6B36 CD7E394D_01 -FFBFFFFF CA800002_00 -FFFF7FFF C7000100_00 -FFFFD055 C63EAC00_00 -FF7FFFFF CB000001_00 -027BFFFE 4C1EFFFF_01 -FF3090D0 CB4F6F30_00 -FEFFFFFF CB800001_01 -00082040 49020400_00 -0000006E 42DC0000_00 -FDFFFFFF CC000001_01 -FDFFFF87 CC00001F_01 -04C3764D 4C986EC9_01 -FBFFFFFF CC800001_01 -0006007E 48C00FC0_00 -000001EF 43F78000_00 -F7FFFFFF CD000001_01 -FFBF7FFE CA810004_00 -FF1C4E5A CB63B1A6_00 -EFFFFFFF CD800001_01 -FFF97FFD C8D00060_00 -000001D1 43E88000_00 -DFFFFFFF CE000001_01 -2FFFFFFE 4E3FFFFF_01 -00136721 499B3908_00 -BFFFFFFF CE800001_01 -00004BFF 4697FE00_00 -00000544 44A88000_00 -7FFFFFFF 4EFFFFFF_01 -007FDFFB 4AFFBFF6_00 -FFF8BD5E C8E85440_00 -3FFFFFFF 4E7FFFFF_01 -FFBF8003 CA80FFFA_00 -FFFE45D2 C7DD1700_00 -1FFFFFFF 4DFFFFFF_01 -FFFFFDBF C4104000_00 -FFFFF189 C5677000_00 -0FFFFFFF 4D7FFFFF_01 -FFFE6FFE C7C80100_00 -FC8672A0 CC5E6358_00 -07FFFFFF 4CFFFFFF_01 -00000107 43838000_00 -FFFCCA70 C84D6400_00 -03FFFFFF 4C7FFFFF_01 -002107FE 4A041FF8_00 -FFFF48E7 C7371900_00 -01FFFFFF 4BFFFFFF_01 -F7FDFFEE CD002002_01 -00000010 41800000_00 -00FFFFFF 4B7FFFFF_00 -FFFF01FD C77E0300_00 -0000FAEF 477AEF00_00 -007FFFFF 4AFFFFFE_00 -00FC0001 4B7C0001_00 -000000F5 43750000_00 -003FFFFF 4A7FFFFC_00 -FFE07FC0 C9FC0200_00 -001AFFFB 49D7FFD8_00 -001FFFFF 49FFFFF8_00 -00101FFD 4980FFE8_00 -FF4613B2 CB39EC4E_00 -000FFFFF 497FFFF0_00 -F00005FE CD7FFFA1_01 -00036402 48590080_00 -0007FFFF 48FFFFE0_00 -0404FFFF 4C809FFF_01 -021C2358 4C0708D6_00 -0003FFFF 487FFFC0_00 -FFFFFD02 C43F8000_00 -FFFF41C6 C73E3A00_00 -0001FFFF 47FFFF80_00 -00000007 40E00000_00 -27F174DE 4E1FC5D3_01 -0000FFFF 477FFF00_00 -000083F5 4703F500_00 -FFFFFFFB C0A00000_00 -00007FFF 46FFFE00_00 -FE7FDFFE CBC01001_00 -FFFFFFFD C0400000_00 -00003FFF 467FFC00_00 -DBBFFFFE CE110001_01 -00000404 44808000_00 -00001FFF 45FFF800_00 -FFFFC018 C67FA000_00 -00002853 46214C00_00 -00000FFF 457FF000_00 -03FE007F 4C7F801F_01 -FFFFF124 C56DC000_00 -000007FF 44FFE000_00 -FFFFEFBE C5821000_00 -FFFB9AD8 C88CA500_00 -000003FF 447FC000_00 -DFFFFDFE CE000009_01 -FFFFFD95 C41AC000_00 -000001FF 43FF8000_00 -FDFFFFFF CC000001_01 -FFFFFFD0 C2400000_00 -000000FF 437F0000_00 -0037FFE0 4A5FFF80_00 -010EC496 4B87624B_00 -0000007F 42FE0000_00 -B8007FFF CE8FFF01_01 -00000012 41900000_00 -0000003F 427C0000_00 -02003FFC 4C000FFF_00 -FFFFFFEF C1880000_00 -0000001F 41F80000_00 -FF7FFF02 CB0000FE_00 -FFFFE2CE C5E99000_00 -0000000F 41700000_00 -0000A00D 47200D00_00 -FFFFFE44 C3DE0000_00 -00000007 40E00000_00 -0003FFFA 487FFE80_00 -000038E7 46639C00_00 -00000003 40400000_00 +1FEFFFEF_4DFF7FFF_01 +FFFFC48E_C66DC800_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00009E14_471E1400_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +FFFFDE38_C6072000_00 +00000002_40000000_00 +FFDFFC02_CA000FF8_00 +FB794C79_CC90D671_01 +00000004_40800000_00 +F00FFFFE_CD7F0001_01 +00000A95_45295000_00 +00000008_41000000_00 +FFFFF97F_C4D02000_00 +FFAE458D_CAA374E6_00 +00000010_41800000_00 +0101001E_4B80800F_00 +29EB4561_4E27AD15_01 +00000020_42000000_00 +8001FFEE_CEFFFC01_01 +FFFBDD08_C8845F00_00 +00000040_42800000_00 +FFF03FF9_C97C0070_00 +FFCEDF36_CA448328_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000279_441E4000_00 +00000100_43800000_00 +BFFFFFEF_CE800001_01 +00000007_40E00000_00 +00000200_44000000_00 +010BFFFD_4B85FFFE_01 +FFFFF590_C5270000_00 +00000400_44800000_00 +F7FFFEFB_CD000011_01 +2FEA335F_4E3FA8CD_01 +00000800_45000000_00 +FFC07FFF_CA7E0004_00 +177957FD_4DBBCABF_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +FFFFFAC9_C4A6E000_00 +00002000_46000000_00 +FFFF8004_C6FFF800_00 +FFFBE0DE_C883E440_00 +00004000_46800000_00 +3F00001E_4E7C0000_01 +00000000_00000000_00 +00008000_47000000_00 +FF8201FF_CAFBFC02_00 +FFFFD2F1_C6343C00_00 +00010000_47800000_00 +0000047E_448FC000_00 +0011B7E5_498DBF28_00 +00020000_48000000_00 +02200200_4C080080_00 +0013F7E6_499FBF30_00 +00040000_48800000_00 +FFFDC007_C80FFE40_00 +FD0ABD9A_CC3D509A_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00003CEE_4673B800_00 +00100000_49800000_00 +DFDFE000_CE008080_00 +FFFB1642_C89D37C0_00 +00200000_4A000000_00 +FC000078_CC7FFFE2_00 +5F70EEC1_4EBEE1DD_01 +00400000_4A800000_00 +00100082_49800410_00 +FFFFFE21_C3EF8000_00 +00800000_4B000000_00 +FF7BFF7F_CB040081_00 +FFFF6393_C71C6D00_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFDF_01 +FFFFFDB4_C4130000_00 +02000000_4C000000_00 +8002FFFF_CEFFFA01_01 +FFFFC8E2_C65C7800_00 +04000000_4C800000_00 +FFFC0DFE_C87C8080_00 +FFFFFF1B_C3650000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF6F_01 +0001092B_47849580_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +00B4F3D1_4B34F3D1_00 +20000000_4E000000_00 +FEF801FF_CB83FF01_01 +00000005_40A00000_00 +40000000_4E800000_00 +BFF3FFFE_CE801801_01 +0001806B_47C03580_00 +80000000_CF000000_00 +0000A07E_47207E00_00 +FFFFA59F_C6B4C200_00 +C0000000_CE800000_00 +E0007FDE_CDFFFC02_01 +FFF8343E_C8F97840_00 +E0000000_CE000000_00 +0000FF7C_477F7C00_00 +FFFFFFF7_C1100000_00 +F0000000_CD800000_00 +BDFFFFFC_CE840001_01 +FFFFE3C1_C5E1F800_00 +F8000000_CD000000_00 +28003FFE_4E2000FF_01 +00000000_00000000_00 +FC000000_CC800000_00 +00EEFFFF_4B6EFFFF_00 +00003EB0_467AC000_00 +FE000000_CC000000_00 +00000F7D_4577D000_00 +FFFFFF0F_C3710000_00 +FF000000_CB800000_00 +0000406D_4680DA00_00 +0000001A_41D00000_00 +FF800000_CB000000_00 +203FFFFD_4E00FFFF_01 +0000000A_41200000_00 +FFC00000_CA800000_00 +FFFF007C_C77F8400_00 +0000009B_431B0000_00 +FFE00000_CA000000_00 +00E00FFF_4B600FFF_00 +00000006_40C00000_00 +FFF00000_C9800000_00 +00200FFC_4A003FF0_00 +00000714_44E28000_00 +FFF80000_C9000000_00 +F800040E_CCFFFF7F_01 +00000013_41980000_00 +FFFC0000_C8800000_00 +F83BFFFF_CCF88001_01 +FFF3F584_C940A7C0_00 +FFFE0000_C8000000_00 +F6FFFBFF_CD100041_01 +FFFFFFF0_C1800000_00 +FFFF0000_C7800000_00 +80003FFD_CEFFFF81_01 +FFFFFFAD_C2A60000_00 +FFFF8000_C7000000_00 +004001FD_4A8003FA_00 +000D734E_495734E0_00 +FFFFC000_C6800000_00 +006003FE_4AC007FC_00 +FF9DBAA8_CAC48AB0_00 +FFFFE000_C6000000_00 +000403EE_48807DC0_00 +00734668_4AE68CD0_00 +FFFFF000_C5800000_00 +01200002_4B900001_00 +FF8874A5_CAEF16B6_00 +FFFFF800_C5000000_00 +00060001_48C00020_00 +FFFFFFF8_C1000000_00 +FFFFFC00_C4800000_00 +001FFEDD_49FFF6E8_00 +FFFC56DF_C86A4840_00 +FFFFFE00_C4000000_00 +EFFFEFFD_CD800081_01 +FECF5EC6_CB98509D_00 +FFFFFF00_C3800000_00 +1FF00002_4DFF8000_01 +F6DB786B_CD12487A_01 +FFFFFF80_C3000000_00 +F0000FBE_CD7FFF05_01 +00000009_41100000_00 +FFFFFFC0_C2800000_00 +0010801F_498400F8_00 +0001F238_47F91C00_00 +FFFFFFE0_C2000000_00 +F8000047_CCFFFFF8_01 +0002133C_4804CF00_00 +FFFFFFF0_C1800000_00 +003C001F_4A70007C_00 +000001F1_43F88000_00 +FFFFFFF8_C1000000_00 +FFDFBFFF_CA010004_00 +FF5E507F_CB21AF81_00 +FFFFFFFC_C0800000_00 +037FFFDE_4C5FFFF7_01 +FFFD7C6F_C820E440_00 +FFFFFFFE_C0000000_00 +000000FD_437D0000_00 +FFFFF42A_C53D6000_00 +FFFFFFFF_BF800000_00 +021FFF7D_4C07FFDF_01 +0000000A_41200000_00 +FFFFFFFD_C0400000_00 +4010FFFF_4E8021FF_01 +FFFFFFD3_C2340000_00 +FFFFFFFB_C0A00000_00 +FFFF800B_C6FFEA00_00 +000000B8_43380000_00 +FFFFFFF7_C1100000_00 +FF800803_CAFFEFFA_00 +FFFFFFFE_C0000000_00 +FFFFFFEF_C1880000_00 +00803FFB_4B003FFB_00 +00000308_44420000_00 +FFFFFFDF_C2040000_00 +2107FFFE_4E041FFF_01 +FFE15D4F_C9F51588_00 +FFFFFFBF_C2820000_00 +400087FD_4E80010F_01 +0000000F_41700000_00 +FFFFFF7F_C3010000_00 +FDFC007E_CC00FFE1_01 +00000006_40C00000_00 +FFFFFEFF_C3808000_00 +FFF80100_C8FFE000_00 +FFFFFE99_C3B38000_00 +FFFFFDFF_C4004000_00 +03000002_4C400000_01 +FFF716EA_C90E9160_00 +FFFFFBFF_C4802000_00 +C7FDFFFF_CE600801_01 +FFFFE327_C5E6C800_00 +FFFFF7FF_C5001000_00 +0103DFFE_4B81EFFF_00 +07661FD8_4CECC3FB_00 +FFFFEFFF_C5800800_00 +83FFFFFE_CEF80001_01 +FCD956DB_CC49AA4A_01 +FFFFDFFF_C6000400_00 +FF2001FD_CB5FFE03_00 +E4D35BBF_CDD96523_01 +FFFFBFFF_C6800200_00 +DFEFEFFE_CE004041_01 +05DA4300_4CBB4860_00 +FFFF7FFF_C7000100_00 +40001040_4E800020_01 +812EDF40_CEFDA242_01 +FFFEFFFF_C7800080_00 +FFFFC007_C67FE400_00 +00B6FCC9_4B36FCC9_00 +FFFDFFFF_C8000040_00 +000007FE_44FFC000_00 +FC3DE950_CC7085AC_00 +FFFBFFFF_C8800020_00 +7FFFFE03_4EFFFFFC_01 +FEB02B59_CBA7EA54_01 +FFF7FFFF_C9000010_00 +10FF7FFF_4D87FBFF_01 +00008D5E_470D5E00_00 +FFEFFFFF_C9800008_00 +FFFF007E_C77F8200_00 +001C2108_49E10840_00 +FFDFFFFF_CA000004_00 +00FFC001_4B7FC001_00 +F01C6B36_CD7E394D_01 +FFBFFFFF_CA800002_00 +FFFF7FFF_C7000100_00 +FFFFD055_C63EAC00_00 +FF7FFFFF_CB000001_00 +027BFFFE_4C1EFFFF_01 +FF3090D0_CB4F6F30_00 +FEFFFFFF_CB800001_01 +00082040_49020400_00 +0000006E_42DC0000_00 +FDFFFFFF_CC000001_01 +FDFFFF87_CC00001F_01 +04C3764D_4C986EC9_01 +FBFFFFFF_CC800001_01 +0006007E_48C00FC0_00 +000001EF_43F78000_00 +F7FFFFFF_CD000001_01 +FFBF7FFE_CA810004_00 +FF1C4E5A_CB63B1A6_00 +EFFFFFFF_CD800001_01 +FFF97FFD_C8D00060_00 +000001D1_43E88000_00 +DFFFFFFF_CE000001_01 +2FFFFFFE_4E3FFFFF_01 +00136721_499B3908_00 +BFFFFFFF_CE800001_01 +00004BFF_4697FE00_00 +00000544_44A88000_00 +7FFFFFFF_4EFFFFFF_01 +007FDFFB_4AFFBFF6_00 +FFF8BD5E_C8E85440_00 +3FFFFFFF_4E7FFFFF_01 +FFBF8003_CA80FFFA_00 +FFFE45D2_C7DD1700_00 +1FFFFFFF_4DFFFFFF_01 +FFFFFDBF_C4104000_00 +FFFFF189_C5677000_00 +0FFFFFFF_4D7FFFFF_01 +FFFE6FFE_C7C80100_00 +FC8672A0_CC5E6358_00 +07FFFFFF_4CFFFFFF_01 +00000107_43838000_00 +FFFCCA70_C84D6400_00 +03FFFFFF_4C7FFFFF_01 +002107FE_4A041FF8_00 +FFFF48E7_C7371900_00 +01FFFFFF_4BFFFFFF_01 +F7FDFFEE_CD002002_01 +00000010_41800000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_C77E0300_00 +0000FAEF_477AEF00_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000000F5_43750000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_C9FC0200_00 +001AFFFB_49D7FFD8_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +FF4613B2_CB39EC4E_00 +000FFFFF_497FFFF0_00 +F00005FE_CD7FFFA1_01 +00036402_48590080_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C809FFF_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_C43F8000_00 +FFFF41C6_C73E3A00_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D3_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +FFFFFFFB_C0A00000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_CBC01001_00 +FFFFFFFD_C0400000_00 +00003FFF_467FFC00_00 +DBBFFFFE_CE110001_01 +00000404_44808000_00 +00001FFF_45FFF800_00 +FFFFC018_C67FA000_00 +00002853_46214C00_00 +00000FFF_457FF000_00 +03FE007F_4C7F801F_01 +FFFFF124_C56DC000_00 +000007FF_44FFE000_00 +FFFFEFBE_C5821000_00 +FFFB9AD8_C88CA500_00 +000003FF_447FC000_00 +DFFFFDFE_CE000009_01 +FFFFFD95_C41AC000_00 +000001FF_43FF8000_00 +FDFFFFFF_CC000001_01 +FFFFFFD0_C2400000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +010EC496_4B87624B_00 +0000007F_42FE0000_00 +B8007FFF_CE8FFF01_01 +00000012_41900000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +FFFFFFEF_C1880000_00 +0000001F_41F80000_00 +FF7FFF02_CB0000FE_00 +FFFFE2CE_C5E99000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +FFFFFE44_C3DE0000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +000038E7_46639C00_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f32_rne.tv b/wally-pipelined/testbench/fp/i32_f32_rne.tv index 47d0f04bb..ddf40de77 100644 --- a/wally-pipelined/testbench/fp/i32_f32_rne.tv +++ b/wally-pipelined/testbench/fp/i32_f32_rne.tv @@ -1,372 +1,372 @@ -1FEFFFEF 4DFF7FFF_01 -FFFFC48E C66DC800_00 -00000000 00000000_00 -007FFFCD 4AFFFF9A_00 -00009E14 471E1400_00 -00000001 3F800000_00 -001FFFFB 49FFFFD8_00 -FFFFDE38 C6072000_00 -00000002 40000000_00 -FFDFFC02 CA000FF8_00 -FB794C79 CC90D671_01 -00000004 40800000_00 -F00FFFFE CD7F0000_01 -00000A95 45295000_00 -00000008 41000000_00 -FFFFF97F C4D02000_00 -FFAE458D CAA374E6_00 -00000010 41800000_00 -0101001E 4B80800F_00 -29EB4561 4E27AD16_01 -00000020 42000000_00 -8001FFEE CEFFFC00_01 -FFFBDD08 C8845F00_00 -00000040 42800000_00 -FFF03FF9 C97C0070_00 -FFCEDF36 CA448328_00 -00000080 43000000_00 -0000F01F 47701F00_00 -00000279 441E4000_00 -00000100 43800000_00 -BFFFFFEF CE800000_01 -00000007 40E00000_00 -00000200 44000000_00 -010BFFFD 4B85FFFE_01 -FFFFF590 C5270000_00 -00000400 44800000_00 -F7FFFEFB CD000010_01 -2FEA335F 4E3FA8CD_01 -00000800 45000000_00 -FFC07FFF CA7E0004_00 -177957FD 4DBBCAC0_01 -00001000 45800000_00 -01FBFFEE 4BFDFFF7_00 -FFFFFAC9 C4A6E000_00 -00002000 46000000_00 -FFFF8004 C6FFF800_00 -FFFBE0DE C883E440_00 -00004000 46800000_00 -3F00001E 4E7C0000_01 -00000000 00000000_00 -00008000 47000000_00 -FF8201FF CAFBFC02_00 -FFFFD2F1 C6343C00_00 -00010000 47800000_00 -0000047E 448FC000_00 -0011B7E5 498DBF28_00 -00020000 48000000_00 -02200200 4C080080_00 -0013F7E6 499FBF30_00 -00040000 48800000_00 -FFFDC007 C80FFE40_00 -FD0ABD9A CC3D509A_01 -00080000 49000000_00 -0000607F 46C0FE00_00 -00003CEE 4673B800_00 -00100000 49800000_00 -DFDFE000 CE008080_00 -FFFB1642 C89D37C0_00 -00200000 4A000000_00 -FC000078 CC7FFFE2_00 -5F70EEC1 4EBEE1DE_01 -00400000 4A800000_00 -00100082 49800410_00 -FFFFFE21 C3EF8000_00 -00800000 4B000000_00 -FF7BFF7F CB040081_00 -FFFF6393 C71C6D00_00 -01000000 4B800000_00 -07EFFEFD 4CFDFFE0_01 -FFFFFDB4 C4130000_00 -02000000 4C000000_00 -8002FFFF CEFFFA00_01 -FFFFC8E2 C65C7800_00 -04000000 4C800000_00 -FFFC0DFE C87C8080_00 -FFFFFF1B C3650000_00 -08000000 4D000000_00 -03FFFDBF 4C7FFF70_01 -0001092B 47849580_00 -10000000 4D800000_00 -007FBFFD 4AFF7FFA_00 -00B4F3D1 4B34F3D1_00 -20000000 4E000000_00 -FEF801FF CB83FF00_01 -00000005 40A00000_00 -40000000 4E800000_00 -BFF3FFFE CE801800_01 -0001806B 47C03580_00 -80000000 CF000000_00 -0000A07E 47207E00_00 -FFFFA59F C6B4C200_00 -C0000000 CE800000_00 -E0007FDE CDFFFC01_01 -FFF8343E C8F97840_00 -E0000000 CE000000_00 -0000FF7C 477F7C00_00 -FFFFFFF7 C1100000_00 -F0000000 CD800000_00 -BDFFFFFC CE840000_01 -FFFFE3C1 C5E1F800_00 -F8000000 CD000000_00 -28003FFE 4E200100_01 -00000000 00000000_00 -FC000000 CC800000_00 -00EEFFFF 4B6EFFFF_00 -00003EB0 467AC000_00 -FE000000 CC000000_00 -00000F7D 4577D000_00 -FFFFFF0F C3710000_00 -FF000000 CB800000_00 -0000406D 4680DA00_00 -0000001A 41D00000_00 -FF800000 CB000000_00 -203FFFFD 4E010000_01 -0000000A 41200000_00 -FFC00000 CA800000_00 -FFFF007C C77F8400_00 -0000009B 431B0000_00 -FFE00000 CA000000_00 -00E00FFF 4B600FFF_00 -00000006 40C00000_00 -FFF00000 C9800000_00 -00200FFC 4A003FF0_00 -00000714 44E28000_00 -FFF80000 C9000000_00 -F800040E CCFFFF7E_01 -00000013 41980000_00 -FFFC0000 C8800000_00 -F83BFFFF CCF88000_01 -FFF3F584 C940A7C0_00 -FFFE0000 C8000000_00 -F6FFFBFF CD100040_01 -FFFFFFF0 C1800000_00 -FFFF0000 C7800000_00 -80003FFD CEFFFF80_01 -FFFFFFAD C2A60000_00 -FFFF8000 C7000000_00 -004001FD 4A8003FA_00 -000D734E 495734E0_00 -FFFFC000 C6800000_00 -006003FE 4AC007FC_00 -FF9DBAA8 CAC48AB0_00 -FFFFE000 C6000000_00 -000403EE 48807DC0_00 -00734668 4AE68CD0_00 -FFFFF000 C5800000_00 -01200002 4B900001_00 -FF8874A5 CAEF16B6_00 -FFFFF800 C5000000_00 -00060001 48C00020_00 -FFFFFFF8 C1000000_00 -FFFFFC00 C4800000_00 -001FFEDD 49FFF6E8_00 -FFFC56DF C86A4840_00 -FFFFFE00 C4000000_00 -EFFFEFFD CD800080_01 -FECF5EC6 CB98509D_00 -FFFFFF00 C3800000_00 -1FF00002 4DFF8000_01 -F6DB786B CD124879_01 -FFFFFF80 C3000000_00 -F0000FBE CD7FFF04_01 -00000009 41100000_00 -FFFFFFC0 C2800000_00 -0010801F 498400F8_00 -0001F238 47F91C00_00 -FFFFFFE0 C2000000_00 -F8000047 CCFFFFF7_01 -0002133C 4804CF00_00 -FFFFFFF0 C1800000_00 -003C001F 4A70007C_00 -000001F1 43F88000_00 -FFFFFFF8 C1000000_00 -FFDFBFFF CA010004_00 -FF5E507F CB21AF81_00 -FFFFFFFC C0800000_00 -037FFFDE 4C5FFFF8_01 -FFFD7C6F C820E440_00 -FFFFFFFE C0000000_00 -000000FD 437D0000_00 -FFFFF42A C53D6000_00 -FFFFFFFF BF800000_00 -021FFF7D 4C07FFDF_01 -0000000A 41200000_00 -FFFFFFFD C0400000_00 -4010FFFF 4E802200_01 -FFFFFFD3 C2340000_00 -FFFFFFFB C0A00000_00 -FFFF800B C6FFEA00_00 -000000B8 43380000_00 -FFFFFFF7 C1100000_00 -FF800803 CAFFEFFA_00 -FFFFFFFE C0000000_00 -FFFFFFEF C1880000_00 -00803FFB 4B003FFB_00 -00000308 44420000_00 -FFFFFFDF C2040000_00 -2107FFFE 4E042000_01 -FFE15D4F C9F51588_00 -FFFFFFBF C2820000_00 -400087FD 4E800110_01 -0000000F 41700000_00 -FFFFFF7F C3010000_00 -FDFC007E CC00FFE0_01 -00000006 40C00000_00 -FFFFFEFF C3808000_00 -FFF80100 C8FFE000_00 -FFFFFE99 C3B38000_00 -FFFFFDFF C4004000_00 -03000002 4C400000_01 -FFF716EA C90E9160_00 -FFFFFBFF C4802000_00 -C7FDFFFF CE600800_01 -FFFFE327 C5E6C800_00 -FFFFF7FF C5001000_00 -0103DFFE 4B81EFFF_00 -07661FD8 4CECC3FB_00 -FFFFEFFF C5800800_00 -83FFFFFE CEF80000_01 -FCD956DB CC49AA49_01 -FFFFDFFF C6000400_00 -FF2001FD CB5FFE03_00 -E4D35BBF CDD96522_01 -FFFFBFFF C6800200_00 -DFEFEFFE CE004040_01 -05DA4300 4CBB4860_00 -FFFF7FFF C7000100_00 -40001040 4E800020_01 -812EDF40 CEFDA242_01 -FFFEFFFF C7800080_00 -FFFFC007 C67FE400_00 -00B6FCC9 4B36FCC9_00 -FFFDFFFF C8000040_00 -000007FE 44FFC000_00 -FC3DE950 CC7085AC_00 -FFFBFFFF C8800020_00 -7FFFFE03 4EFFFFFC_01 -FEB02B59 CBA7EA54_01 -FFF7FFFF C9000010_00 -10FF7FFF 4D87FC00_01 -00008D5E 470D5E00_00 -FFEFFFFF C9800008_00 -FFFF007E C77F8200_00 -001C2108 49E10840_00 -FFDFFFFF CA000004_00 -00FFC001 4B7FC001_00 -F01C6B36 CD7E394D_01 -FFBFFFFF CA800002_00 -FFFF7FFF C7000100_00 -FFFFD055 C63EAC00_00 -FF7FFFFF CB000001_00 -027BFFFE 4C1F0000_01 -FF3090D0 CB4F6F30_00 -FEFFFFFF CB800000_01 -00082040 49020400_00 -0000006E 42DC0000_00 -FDFFFFFF CC000000_01 -FDFFFF87 CC00001E_01 -04C3764D 4C986ECA_01 -FBFFFFFF CC800000_01 -0006007E 48C00FC0_00 -000001EF 43F78000_00 -F7FFFFFF CD000000_01 -FFBF7FFE CA810004_00 -FF1C4E5A CB63B1A6_00 -EFFFFFFF CD800000_01 -FFF97FFD C8D00060_00 -000001D1 43E88000_00 -DFFFFFFF CE000000_01 -2FFFFFFE 4E400000_01 -00136721 499B3908_00 -BFFFFFFF CE800000_01 -00004BFF 4697FE00_00 -00000544 44A88000_00 -7FFFFFFF 4F000000_01 -007FDFFB 4AFFBFF6_00 -FFF8BD5E C8E85440_00 -3FFFFFFF 4E800000_01 -FFBF8003 CA80FFFA_00 -FFFE45D2 C7DD1700_00 -1FFFFFFF 4E000000_01 -FFFFFDBF C4104000_00 -FFFFF189 C5677000_00 -0FFFFFFF 4D800000_01 -FFFE6FFE C7C80100_00 -FC8672A0 CC5E6358_00 -07FFFFFF 4D000000_01 -00000107 43838000_00 -FFFCCA70 C84D6400_00 -03FFFFFF 4C800000_01 -002107FE 4A041FF8_00 -FFFF48E7 C7371900_00 -01FFFFFF 4C000000_01 -F7FDFFEE CD002001_01 -00000010 41800000_00 -00FFFFFF 4B7FFFFF_00 -FFFF01FD C77E0300_00 -0000FAEF 477AEF00_00 -007FFFFF 4AFFFFFE_00 -00FC0001 4B7C0001_00 -000000F5 43750000_00 -003FFFFF 4A7FFFFC_00 -FFE07FC0 C9FC0200_00 -001AFFFB 49D7FFD8_00 -001FFFFF 49FFFFF8_00 -00101FFD 4980FFE8_00 -FF4613B2 CB39EC4E_00 -000FFFFF 497FFFF0_00 -F00005FE CD7FFFA0_01 -00036402 48590080_00 -0007FFFF 48FFFFE0_00 -0404FFFF 4C80A000_01 -021C2358 4C0708D6_00 -0003FFFF 487FFFC0_00 -FFFFFD02 C43F8000_00 -FFFF41C6 C73E3A00_00 -0001FFFF 47FFFF80_00 -00000007 40E00000_00 -27F174DE 4E1FC5D3_01 -0000FFFF 477FFF00_00 -000083F5 4703F500_00 -FFFFFFFB C0A00000_00 -00007FFF 46FFFE00_00 -FE7FDFFE CBC01001_00 -FFFFFFFD C0400000_00 -00003FFF 467FFC00_00 -DBBFFFFE CE110000_01 -00000404 44808000_00 -00001FFF 45FFF800_00 -FFFFC018 C67FA000_00 -00002853 46214C00_00 -00000FFF 457FF000_00 -03FE007F 4C7F8020_01 -FFFFF124 C56DC000_00 -000007FF 44FFE000_00 -FFFFEFBE C5821000_00 -FFFB9AD8 C88CA500_00 -000003FF 447FC000_00 -DFFFFDFE CE000008_01 -FFFFFD95 C41AC000_00 -000001FF 43FF8000_00 -FDFFFFFF CC000000_01 -FFFFFFD0 C2400000_00 -000000FF 437F0000_00 -0037FFE0 4A5FFF80_00 -010EC496 4B87624B_00 -0000007F 42FE0000_00 -B8007FFF CE8FFF00_01 -00000012 41900000_00 -0000003F 427C0000_00 -02003FFC 4C000FFF_00 -FFFFFFEF C1880000_00 -0000001F 41F80000_00 -FF7FFF02 CB0000FE_00 -FFFFE2CE C5E99000_00 -0000000F 41700000_00 -0000A00D 47200D00_00 -FFFFFE44 C3DE0000_00 -00000007 40E00000_00 -0003FFFA 487FFE80_00 -000038E7 46639C00_00 -00000003 40400000_00 +1FEFFFEF_4DFF7FFF_01 +FFFFC48E_C66DC800_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00009E14_471E1400_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +FFFFDE38_C6072000_00 +00000002_40000000_00 +FFDFFC02_CA000FF8_00 +FB794C79_CC90D671_01 +00000004_40800000_00 +F00FFFFE_CD7F0000_01 +00000A95_45295000_00 +00000008_41000000_00 +FFFFF97F_C4D02000_00 +FFAE458D_CAA374E6_00 +00000010_41800000_00 +0101001E_4B80800F_00 +29EB4561_4E27AD16_01 +00000020_42000000_00 +8001FFEE_CEFFFC00_01 +FFFBDD08_C8845F00_00 +00000040_42800000_00 +FFF03FF9_C97C0070_00 +FFCEDF36_CA448328_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000279_441E4000_00 +00000100_43800000_00 +BFFFFFEF_CE800000_01 +00000007_40E00000_00 +00000200_44000000_00 +010BFFFD_4B85FFFE_01 +FFFFF590_C5270000_00 +00000400_44800000_00 +F7FFFEFB_CD000010_01 +2FEA335F_4E3FA8CD_01 +00000800_45000000_00 +FFC07FFF_CA7E0004_00 +177957FD_4DBBCAC0_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +FFFFFAC9_C4A6E000_00 +00002000_46000000_00 +FFFF8004_C6FFF800_00 +FFFBE0DE_C883E440_00 +00004000_46800000_00 +3F00001E_4E7C0000_01 +00000000_00000000_00 +00008000_47000000_00 +FF8201FF_CAFBFC02_00 +FFFFD2F1_C6343C00_00 +00010000_47800000_00 +0000047E_448FC000_00 +0011B7E5_498DBF28_00 +00020000_48000000_00 +02200200_4C080080_00 +0013F7E6_499FBF30_00 +00040000_48800000_00 +FFFDC007_C80FFE40_00 +FD0ABD9A_CC3D509A_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00003CEE_4673B800_00 +00100000_49800000_00 +DFDFE000_CE008080_00 +FFFB1642_C89D37C0_00 +00200000_4A000000_00 +FC000078_CC7FFFE2_00 +5F70EEC1_4EBEE1DE_01 +00400000_4A800000_00 +00100082_49800410_00 +FFFFFE21_C3EF8000_00 +00800000_4B000000_00 +FF7BFF7F_CB040081_00 +FFFF6393_C71C6D00_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFE0_01 +FFFFFDB4_C4130000_00 +02000000_4C000000_00 +8002FFFF_CEFFFA00_01 +FFFFC8E2_C65C7800_00 +04000000_4C800000_00 +FFFC0DFE_C87C8080_00 +FFFFFF1B_C3650000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF70_01 +0001092B_47849580_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +00B4F3D1_4B34F3D1_00 +20000000_4E000000_00 +FEF801FF_CB83FF00_01 +00000005_40A00000_00 +40000000_4E800000_00 +BFF3FFFE_CE801800_01 +0001806B_47C03580_00 +80000000_CF000000_00 +0000A07E_47207E00_00 +FFFFA59F_C6B4C200_00 +C0000000_CE800000_00 +E0007FDE_CDFFFC01_01 +FFF8343E_C8F97840_00 +E0000000_CE000000_00 +0000FF7C_477F7C00_00 +FFFFFFF7_C1100000_00 +F0000000_CD800000_00 +BDFFFFFC_CE840000_01 +FFFFE3C1_C5E1F800_00 +F8000000_CD000000_00 +28003FFE_4E200100_01 +00000000_00000000_00 +FC000000_CC800000_00 +00EEFFFF_4B6EFFFF_00 +00003EB0_467AC000_00 +FE000000_CC000000_00 +00000F7D_4577D000_00 +FFFFFF0F_C3710000_00 +FF000000_CB800000_00 +0000406D_4680DA00_00 +0000001A_41D00000_00 +FF800000_CB000000_00 +203FFFFD_4E010000_01 +0000000A_41200000_00 +FFC00000_CA800000_00 +FFFF007C_C77F8400_00 +0000009B_431B0000_00 +FFE00000_CA000000_00 +00E00FFF_4B600FFF_00 +00000006_40C00000_00 +FFF00000_C9800000_00 +00200FFC_4A003FF0_00 +00000714_44E28000_00 +FFF80000_C9000000_00 +F800040E_CCFFFF7E_01 +00000013_41980000_00 +FFFC0000_C8800000_00 +F83BFFFF_CCF88000_01 +FFF3F584_C940A7C0_00 +FFFE0000_C8000000_00 +F6FFFBFF_CD100040_01 +FFFFFFF0_C1800000_00 +FFFF0000_C7800000_00 +80003FFD_CEFFFF80_01 +FFFFFFAD_C2A60000_00 +FFFF8000_C7000000_00 +004001FD_4A8003FA_00 +000D734E_495734E0_00 +FFFFC000_C6800000_00 +006003FE_4AC007FC_00 +FF9DBAA8_CAC48AB0_00 +FFFFE000_C6000000_00 +000403EE_48807DC0_00 +00734668_4AE68CD0_00 +FFFFF000_C5800000_00 +01200002_4B900001_00 +FF8874A5_CAEF16B6_00 +FFFFF800_C5000000_00 +00060001_48C00020_00 +FFFFFFF8_C1000000_00 +FFFFFC00_C4800000_00 +001FFEDD_49FFF6E8_00 +FFFC56DF_C86A4840_00 +FFFFFE00_C4000000_00 +EFFFEFFD_CD800080_01 +FECF5EC6_CB98509D_00 +FFFFFF00_C3800000_00 +1FF00002_4DFF8000_01 +F6DB786B_CD124879_01 +FFFFFF80_C3000000_00 +F0000FBE_CD7FFF04_01 +00000009_41100000_00 +FFFFFFC0_C2800000_00 +0010801F_498400F8_00 +0001F238_47F91C00_00 +FFFFFFE0_C2000000_00 +F8000047_CCFFFFF7_01 +0002133C_4804CF00_00 +FFFFFFF0_C1800000_00 +003C001F_4A70007C_00 +000001F1_43F88000_00 +FFFFFFF8_C1000000_00 +FFDFBFFF_CA010004_00 +FF5E507F_CB21AF81_00 +FFFFFFFC_C0800000_00 +037FFFDE_4C5FFFF8_01 +FFFD7C6F_C820E440_00 +FFFFFFFE_C0000000_00 +000000FD_437D0000_00 +FFFFF42A_C53D6000_00 +FFFFFFFF_BF800000_00 +021FFF7D_4C07FFDF_01 +0000000A_41200000_00 +FFFFFFFD_C0400000_00 +4010FFFF_4E802200_01 +FFFFFFD3_C2340000_00 +FFFFFFFB_C0A00000_00 +FFFF800B_C6FFEA00_00 +000000B8_43380000_00 +FFFFFFF7_C1100000_00 +FF800803_CAFFEFFA_00 +FFFFFFFE_C0000000_00 +FFFFFFEF_C1880000_00 +00803FFB_4B003FFB_00 +00000308_44420000_00 +FFFFFFDF_C2040000_00 +2107FFFE_4E042000_01 +FFE15D4F_C9F51588_00 +FFFFFFBF_C2820000_00 +400087FD_4E800110_01 +0000000F_41700000_00 +FFFFFF7F_C3010000_00 +FDFC007E_CC00FFE0_01 +00000006_40C00000_00 +FFFFFEFF_C3808000_00 +FFF80100_C8FFE000_00 +FFFFFE99_C3B38000_00 +FFFFFDFF_C4004000_00 +03000002_4C400000_01 +FFF716EA_C90E9160_00 +FFFFFBFF_C4802000_00 +C7FDFFFF_CE600800_01 +FFFFE327_C5E6C800_00 +FFFFF7FF_C5001000_00 +0103DFFE_4B81EFFF_00 +07661FD8_4CECC3FB_00 +FFFFEFFF_C5800800_00 +83FFFFFE_CEF80000_01 +FCD956DB_CC49AA49_01 +FFFFDFFF_C6000400_00 +FF2001FD_CB5FFE03_00 +E4D35BBF_CDD96522_01 +FFFFBFFF_C6800200_00 +DFEFEFFE_CE004040_01 +05DA4300_4CBB4860_00 +FFFF7FFF_C7000100_00 +40001040_4E800020_01 +812EDF40_CEFDA242_01 +FFFEFFFF_C7800080_00 +FFFFC007_C67FE400_00 +00B6FCC9_4B36FCC9_00 +FFFDFFFF_C8000040_00 +000007FE_44FFC000_00 +FC3DE950_CC7085AC_00 +FFFBFFFF_C8800020_00 +7FFFFE03_4EFFFFFC_01 +FEB02B59_CBA7EA54_01 +FFF7FFFF_C9000010_00 +10FF7FFF_4D87FC00_01 +00008D5E_470D5E00_00 +FFEFFFFF_C9800008_00 +FFFF007E_C77F8200_00 +001C2108_49E10840_00 +FFDFFFFF_CA000004_00 +00FFC001_4B7FC001_00 +F01C6B36_CD7E394D_01 +FFBFFFFF_CA800002_00 +FFFF7FFF_C7000100_00 +FFFFD055_C63EAC00_00 +FF7FFFFF_CB000001_00 +027BFFFE_4C1F0000_01 +FF3090D0_CB4F6F30_00 +FEFFFFFF_CB800000_01 +00082040_49020400_00 +0000006E_42DC0000_00 +FDFFFFFF_CC000000_01 +FDFFFF87_CC00001E_01 +04C3764D_4C986ECA_01 +FBFFFFFF_CC800000_01 +0006007E_48C00FC0_00 +000001EF_43F78000_00 +F7FFFFFF_CD000000_01 +FFBF7FFE_CA810004_00 +FF1C4E5A_CB63B1A6_00 +EFFFFFFF_CD800000_01 +FFF97FFD_C8D00060_00 +000001D1_43E88000_00 +DFFFFFFF_CE000000_01 +2FFFFFFE_4E400000_01 +00136721_499B3908_00 +BFFFFFFF_CE800000_01 +00004BFF_4697FE00_00 +00000544_44A88000_00 +7FFFFFFF_4F000000_01 +007FDFFB_4AFFBFF6_00 +FFF8BD5E_C8E85440_00 +3FFFFFFF_4E800000_01 +FFBF8003_CA80FFFA_00 +FFFE45D2_C7DD1700_00 +1FFFFFFF_4E000000_01 +FFFFFDBF_C4104000_00 +FFFFF189_C5677000_00 +0FFFFFFF_4D800000_01 +FFFE6FFE_C7C80100_00 +FC8672A0_CC5E6358_00 +07FFFFFF_4D000000_01 +00000107_43838000_00 +FFFCCA70_C84D6400_00 +03FFFFFF_4C800000_01 +002107FE_4A041FF8_00 +FFFF48E7_C7371900_00 +01FFFFFF_4C000000_01 +F7FDFFEE_CD002001_01 +00000010_41800000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_C77E0300_00 +0000FAEF_477AEF00_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000000F5_43750000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_C9FC0200_00 +001AFFFB_49D7FFD8_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +FF4613B2_CB39EC4E_00 +000FFFFF_497FFFF0_00 +F00005FE_CD7FFFA0_01 +00036402_48590080_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C80A000_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_C43F8000_00 +FFFF41C6_C73E3A00_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D3_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +FFFFFFFB_C0A00000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_CBC01001_00 +FFFFFFFD_C0400000_00 +00003FFF_467FFC00_00 +DBBFFFFE_CE110000_01 +00000404_44808000_00 +00001FFF_45FFF800_00 +FFFFC018_C67FA000_00 +00002853_46214C00_00 +00000FFF_457FF000_00 +03FE007F_4C7F8020_01 +FFFFF124_C56DC000_00 +000007FF_44FFE000_00 +FFFFEFBE_C5821000_00 +FFFB9AD8_C88CA500_00 +000003FF_447FC000_00 +DFFFFDFE_CE000008_01 +FFFFFD95_C41AC000_00 +000001FF_43FF8000_00 +FDFFFFFF_CC000000_01 +FFFFFFD0_C2400000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +010EC496_4B87624B_00 +0000007F_42FE0000_00 +B8007FFF_CE8FFF00_01 +00000012_41900000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +FFFFFFEF_C1880000_00 +0000001F_41F80000_00 +FF7FFF02_CB0000FE_00 +FFFFE2CE_C5E99000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +FFFFFE44_C3DE0000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +000038E7_46639C00_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f32_ru.tv b/wally-pipelined/testbench/fp/i32_f32_ru.tv index b13580f92..bb90896f2 100644 --- a/wally-pipelined/testbench/fp/i32_f32_ru.tv +++ b/wally-pipelined/testbench/fp/i32_f32_ru.tv @@ -1,372 +1,372 @@ -1FEFFFEF 4DFF8000_01 -FFFFC48E C66DC800_00 -00000000 00000000_00 -007FFFCD 4AFFFF9A_00 -00009E14 471E1400_00 -00000001 3F800000_00 -001FFFFB 49FFFFD8_00 -FFFFDE38 C6072000_00 -00000002 40000000_00 -FFDFFC02 CA000FF8_00 -FB794C79 CC90D670_01 -00000004 40800000_00 -F00FFFFE CD7F0000_01 -00000A95 45295000_00 -00000008 41000000_00 -FFFFF97F C4D02000_00 -FFAE458D CAA374E6_00 -00000010 41800000_00 -0101001E 4B80800F_00 -29EB4561 4E27AD16_01 -00000020 42000000_00 -8001FFEE CEFFFC00_01 -FFFBDD08 C8845F00_00 -00000040 42800000_00 -FFF03FF9 C97C0070_00 -FFCEDF36 CA448328_00 -00000080 43000000_00 -0000F01F 47701F00_00 -00000279 441E4000_00 -00000100 43800000_00 -BFFFFFEF CE800000_01 -00000007 40E00000_00 -00000200 44000000_00 -010BFFFD 4B85FFFF_01 -FFFFF590 C5270000_00 -00000400 44800000_00 -F7FFFEFB CD000010_01 -2FEA335F 4E3FA8CE_01 -00000800 45000000_00 -FFC07FFF CA7E0004_00 -177957FD 4DBBCAC0_01 -00001000 45800000_00 -01FBFFEE 4BFDFFF7_00 -FFFFFAC9 C4A6E000_00 -00002000 46000000_00 -FFFF8004 C6FFF800_00 -FFFBE0DE C883E440_00 -00004000 46800000_00 -3F00001E 4E7C0001_01 -00000000 00000000_00 -00008000 47000000_00 -FF8201FF CAFBFC02_00 -FFFFD2F1 C6343C00_00 -00010000 47800000_00 -0000047E 448FC000_00 -0011B7E5 498DBF28_00 -00020000 48000000_00 -02200200 4C080080_00 -0013F7E6 499FBF30_00 -00040000 48800000_00 -FFFDC007 C80FFE40_00 -FD0ABD9A CC3D5099_01 -00080000 49000000_00 -0000607F 46C0FE00_00 -00003CEE 4673B800_00 -00100000 49800000_00 -DFDFE000 CE008080_00 -FFFB1642 C89D37C0_00 -00200000 4A000000_00 -FC000078 CC7FFFE2_00 -5F70EEC1 4EBEE1DE_01 -00400000 4A800000_00 -00100082 49800410_00 -FFFFFE21 C3EF8000_00 -00800000 4B000000_00 -FF7BFF7F CB040081_00 -FFFF6393 C71C6D00_00 -01000000 4B800000_00 -07EFFEFD 4CFDFFE0_01 -FFFFFDB4 C4130000_00 -02000000 4C000000_00 -8002FFFF CEFFFA00_01 -FFFFC8E2 C65C7800_00 -04000000 4C800000_00 -FFFC0DFE C87C8080_00 -FFFFFF1B C3650000_00 -08000000 4D000000_00 -03FFFDBF 4C7FFF70_01 -0001092B 47849580_00 -10000000 4D800000_00 -007FBFFD 4AFF7FFA_00 -00B4F3D1 4B34F3D1_00 -20000000 4E000000_00 -FEF801FF CB83FF00_01 -00000005 40A00000_00 -40000000 4E800000_00 -BFF3FFFE CE801800_01 -0001806B 47C03580_00 -80000000 CF000000_00 -0000A07E 47207E00_00 -FFFFA59F C6B4C200_00 -C0000000 CE800000_00 -E0007FDE CDFFFC01_01 -FFF8343E C8F97840_00 -E0000000 CE000000_00 -0000FF7C 477F7C00_00 -FFFFFFF7 C1100000_00 -F0000000 CD800000_00 -BDFFFFFC CE840000_01 -FFFFE3C1 C5E1F800_00 -F8000000 CD000000_00 -28003FFE 4E200100_01 -00000000 00000000_00 -FC000000 CC800000_00 -00EEFFFF 4B6EFFFF_00 -00003EB0 467AC000_00 -FE000000 CC000000_00 -00000F7D 4577D000_00 -FFFFFF0F C3710000_00 -FF000000 CB800000_00 -0000406D 4680DA00_00 -0000001A 41D00000_00 -FF800000 CB000000_00 -203FFFFD 4E010000_01 -0000000A 41200000_00 -FFC00000 CA800000_00 -FFFF007C C77F8400_00 -0000009B 431B0000_00 -FFE00000 CA000000_00 -00E00FFF 4B600FFF_00 -00000006 40C00000_00 -FFF00000 C9800000_00 -00200FFC 4A003FF0_00 -00000714 44E28000_00 -FFF80000 C9000000_00 -F800040E CCFFFF7E_01 -00000013 41980000_00 -FFFC0000 C8800000_00 -F83BFFFF CCF88000_01 -FFF3F584 C940A7C0_00 -FFFE0000 C8000000_00 -F6FFFBFF CD100040_01 -FFFFFFF0 C1800000_00 -FFFF0000 C7800000_00 -80003FFD CEFFFF80_01 -FFFFFFAD C2A60000_00 -FFFF8000 C7000000_00 -004001FD 4A8003FA_00 -000D734E 495734E0_00 -FFFFC000 C6800000_00 -006003FE 4AC007FC_00 -FF9DBAA8 CAC48AB0_00 -FFFFE000 C6000000_00 -000403EE 48807DC0_00 -00734668 4AE68CD0_00 -FFFFF000 C5800000_00 -01200002 4B900001_00 -FF8874A5 CAEF16B6_00 -FFFFF800 C5000000_00 -00060001 48C00020_00 -FFFFFFF8 C1000000_00 -FFFFFC00 C4800000_00 -001FFEDD 49FFF6E8_00 -FFFC56DF C86A4840_00 -FFFFFE00 C4000000_00 -EFFFEFFD CD800080_01 -FECF5EC6 CB98509D_00 -FFFFFF00 C3800000_00 -1FF00002 4DFF8001_01 -F6DB786B CD124879_01 -FFFFFF80 C3000000_00 -F0000FBE CD7FFF04_01 -00000009 41100000_00 -FFFFFFC0 C2800000_00 -0010801F 498400F8_00 -0001F238 47F91C00_00 -FFFFFFE0 C2000000_00 -F8000047 CCFFFFF7_01 -0002133C 4804CF00_00 -FFFFFFF0 C1800000_00 -003C001F 4A70007C_00 -000001F1 43F88000_00 -FFFFFFF8 C1000000_00 -FFDFBFFF CA010004_00 -FF5E507F CB21AF81_00 -FFFFFFFC C0800000_00 -037FFFDE 4C5FFFF8_01 -FFFD7C6F C820E440_00 -FFFFFFFE C0000000_00 -000000FD 437D0000_00 -FFFFF42A C53D6000_00 -FFFFFFFF BF800000_00 -021FFF7D 4C07FFE0_01 -0000000A 41200000_00 -FFFFFFFD C0400000_00 -4010FFFF 4E802200_01 -FFFFFFD3 C2340000_00 -FFFFFFFB C0A00000_00 -FFFF800B C6FFEA00_00 -000000B8 43380000_00 -FFFFFFF7 C1100000_00 -FF800803 CAFFEFFA_00 -FFFFFFFE C0000000_00 -FFFFFFEF C1880000_00 -00803FFB 4B003FFB_00 -00000308 44420000_00 -FFFFFFDF C2040000_00 -2107FFFE 4E042000_01 -FFE15D4F C9F51588_00 -FFFFFFBF C2820000_00 -400087FD 4E800110_01 -0000000F 41700000_00 -FFFFFF7F C3010000_00 -FDFC007E CC00FFE0_01 -00000006 40C00000_00 -FFFFFEFF C3808000_00 -FFF80100 C8FFE000_00 -FFFFFE99 C3B38000_00 -FFFFFDFF C4004000_00 -03000002 4C400001_01 -FFF716EA C90E9160_00 -FFFFFBFF C4802000_00 -C7FDFFFF CE600800_01 -FFFFE327 C5E6C800_00 -FFFFF7FF C5001000_00 -0103DFFE 4B81EFFF_00 -07661FD8 4CECC3FB_00 -FFFFEFFF C5800800_00 -83FFFFFE CEF80000_01 -FCD956DB CC49AA49_01 -FFFFDFFF C6000400_00 -FF2001FD CB5FFE03_00 -E4D35BBF CDD96522_01 -FFFFBFFF C6800200_00 -DFEFEFFE CE004040_01 -05DA4300 4CBB4860_00 -FFFF7FFF C7000100_00 -40001040 4E800021_01 -812EDF40 CEFDA241_01 -FFFEFFFF C7800080_00 -FFFFC007 C67FE400_00 -00B6FCC9 4B36FCC9_00 -FFFDFFFF C8000040_00 -000007FE 44FFC000_00 -FC3DE950 CC7085AC_00 -FFFBFFFF C8800020_00 -7FFFFE03 4EFFFFFD_01 -FEB02B59 CBA7EA53_01 -FFF7FFFF C9000010_00 -10FF7FFF 4D87FC00_01 -00008D5E 470D5E00_00 -FFEFFFFF C9800008_00 -FFFF007E C77F8200_00 -001C2108 49E10840_00 -FFDFFFFF CA000004_00 -00FFC001 4B7FC001_00 -F01C6B36 CD7E394C_01 -FFBFFFFF CA800002_00 -FFFF7FFF C7000100_00 -FFFFD055 C63EAC00_00 -FF7FFFFF CB000001_00 -027BFFFE 4C1F0000_01 -FF3090D0 CB4F6F30_00 -FEFFFFFF CB800000_01 -00082040 49020400_00 -0000006E 42DC0000_00 -FDFFFFFF CC000000_01 -FDFFFF87 CC00001E_01 -04C3764D 4C986ECA_01 -FBFFFFFF CC800000_01 -0006007E 48C00FC0_00 -000001EF 43F78000_00 -F7FFFFFF CD000000_01 -FFBF7FFE CA810004_00 -FF1C4E5A CB63B1A6_00 -EFFFFFFF CD800000_01 -FFF97FFD C8D00060_00 -000001D1 43E88000_00 -DFFFFFFF CE000000_01 -2FFFFFFE 4E400000_01 -00136721 499B3908_00 -BFFFFFFF CE800000_01 -00004BFF 4697FE00_00 -00000544 44A88000_00 -7FFFFFFF 4F000000_01 -007FDFFB 4AFFBFF6_00 -FFF8BD5E C8E85440_00 -3FFFFFFF 4E800000_01 -FFBF8003 CA80FFFA_00 -FFFE45D2 C7DD1700_00 -1FFFFFFF 4E000000_01 -FFFFFDBF C4104000_00 -FFFFF189 C5677000_00 -0FFFFFFF 4D800000_01 -FFFE6FFE C7C80100_00 -FC8672A0 CC5E6358_00 -07FFFFFF 4D000000_01 -00000107 43838000_00 -FFFCCA70 C84D6400_00 -03FFFFFF 4C800000_01 -002107FE 4A041FF8_00 -FFFF48E7 C7371900_00 -01FFFFFF 4C000000_01 -F7FDFFEE CD002001_01 -00000010 41800000_00 -00FFFFFF 4B7FFFFF_00 -FFFF01FD C77E0300_00 -0000FAEF 477AEF00_00 -007FFFFF 4AFFFFFE_00 -00FC0001 4B7C0001_00 -000000F5 43750000_00 -003FFFFF 4A7FFFFC_00 -FFE07FC0 C9FC0200_00 -001AFFFB 49D7FFD8_00 -001FFFFF 49FFFFF8_00 -00101FFD 4980FFE8_00 -FF4613B2 CB39EC4E_00 -000FFFFF 497FFFF0_00 -F00005FE CD7FFFA0_01 -00036402 48590080_00 -0007FFFF 48FFFFE0_00 -0404FFFF 4C80A000_01 -021C2358 4C0708D6_00 -0003FFFF 487FFFC0_00 -FFFFFD02 C43F8000_00 -FFFF41C6 C73E3A00_00 -0001FFFF 47FFFF80_00 -00000007 40E00000_00 -27F174DE 4E1FC5D4_01 -0000FFFF 477FFF00_00 -000083F5 4703F500_00 -FFFFFFFB C0A00000_00 -00007FFF 46FFFE00_00 -FE7FDFFE CBC01001_00 -FFFFFFFD C0400000_00 -00003FFF 467FFC00_00 -DBBFFFFE CE110000_01 -00000404 44808000_00 -00001FFF 45FFF800_00 -FFFFC018 C67FA000_00 -00002853 46214C00_00 -00000FFF 457FF000_00 -03FE007F 4C7F8020_01 -FFFFF124 C56DC000_00 -000007FF 44FFE000_00 -FFFFEFBE C5821000_00 -FFFB9AD8 C88CA500_00 -000003FF 447FC000_00 -DFFFFDFE CE000008_01 -FFFFFD95 C41AC000_00 -000001FF 43FF8000_00 -FDFFFFFF CC000000_01 -FFFFFFD0 C2400000_00 -000000FF 437F0000_00 -0037FFE0 4A5FFF80_00 -010EC496 4B87624B_00 -0000007F 42FE0000_00 -B8007FFF CE8FFF00_01 -00000012 41900000_00 -0000003F 427C0000_00 -02003FFC 4C000FFF_00 -FFFFFFEF C1880000_00 -0000001F 41F80000_00 -FF7FFF02 CB0000FE_00 -FFFFE2CE C5E99000_00 -0000000F 41700000_00 -0000A00D 47200D00_00 -FFFFFE44 C3DE0000_00 -00000007 40E00000_00 -0003FFFA 487FFE80_00 -000038E7 46639C00_00 -00000003 40400000_00 +1FEFFFEF_4DFF8000_01 +FFFFC48E_C66DC800_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00009E14_471E1400_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +FFFFDE38_C6072000_00 +00000002_40000000_00 +FFDFFC02_CA000FF8_00 +FB794C79_CC90D670_01 +00000004_40800000_00 +F00FFFFE_CD7F0000_01 +00000A95_45295000_00 +00000008_41000000_00 +FFFFF97F_C4D02000_00 +FFAE458D_CAA374E6_00 +00000010_41800000_00 +0101001E_4B80800F_00 +29EB4561_4E27AD16_01 +00000020_42000000_00 +8001FFEE_CEFFFC00_01 +FFFBDD08_C8845F00_00 +00000040_42800000_00 +FFF03FF9_C97C0070_00 +FFCEDF36_CA448328_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000279_441E4000_00 +00000100_43800000_00 +BFFFFFEF_CE800000_01 +00000007_40E00000_00 +00000200_44000000_00 +010BFFFD_4B85FFFF_01 +FFFFF590_C5270000_00 +00000400_44800000_00 +F7FFFEFB_CD000010_01 +2FEA335F_4E3FA8CE_01 +00000800_45000000_00 +FFC07FFF_CA7E0004_00 +177957FD_4DBBCAC0_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +FFFFFAC9_C4A6E000_00 +00002000_46000000_00 +FFFF8004_C6FFF800_00 +FFFBE0DE_C883E440_00 +00004000_46800000_00 +3F00001E_4E7C0001_01 +00000000_00000000_00 +00008000_47000000_00 +FF8201FF_CAFBFC02_00 +FFFFD2F1_C6343C00_00 +00010000_47800000_00 +0000047E_448FC000_00 +0011B7E5_498DBF28_00 +00020000_48000000_00 +02200200_4C080080_00 +0013F7E6_499FBF30_00 +00040000_48800000_00 +FFFDC007_C80FFE40_00 +FD0ABD9A_CC3D5099_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00003CEE_4673B800_00 +00100000_49800000_00 +DFDFE000_CE008080_00 +FFFB1642_C89D37C0_00 +00200000_4A000000_00 +FC000078_CC7FFFE2_00 +5F70EEC1_4EBEE1DE_01 +00400000_4A800000_00 +00100082_49800410_00 +FFFFFE21_C3EF8000_00 +00800000_4B000000_00 +FF7BFF7F_CB040081_00 +FFFF6393_C71C6D00_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFE0_01 +FFFFFDB4_C4130000_00 +02000000_4C000000_00 +8002FFFF_CEFFFA00_01 +FFFFC8E2_C65C7800_00 +04000000_4C800000_00 +FFFC0DFE_C87C8080_00 +FFFFFF1B_C3650000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF70_01 +0001092B_47849580_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +00B4F3D1_4B34F3D1_00 +20000000_4E000000_00 +FEF801FF_CB83FF00_01 +00000005_40A00000_00 +40000000_4E800000_00 +BFF3FFFE_CE801800_01 +0001806B_47C03580_00 +80000000_CF000000_00 +0000A07E_47207E00_00 +FFFFA59F_C6B4C200_00 +C0000000_CE800000_00 +E0007FDE_CDFFFC01_01 +FFF8343E_C8F97840_00 +E0000000_CE000000_00 +0000FF7C_477F7C00_00 +FFFFFFF7_C1100000_00 +F0000000_CD800000_00 +BDFFFFFC_CE840000_01 +FFFFE3C1_C5E1F800_00 +F8000000_CD000000_00 +28003FFE_4E200100_01 +00000000_00000000_00 +FC000000_CC800000_00 +00EEFFFF_4B6EFFFF_00 +00003EB0_467AC000_00 +FE000000_CC000000_00 +00000F7D_4577D000_00 +FFFFFF0F_C3710000_00 +FF000000_CB800000_00 +0000406D_4680DA00_00 +0000001A_41D00000_00 +FF800000_CB000000_00 +203FFFFD_4E010000_01 +0000000A_41200000_00 +FFC00000_CA800000_00 +FFFF007C_C77F8400_00 +0000009B_431B0000_00 +FFE00000_CA000000_00 +00E00FFF_4B600FFF_00 +00000006_40C00000_00 +FFF00000_C9800000_00 +00200FFC_4A003FF0_00 +00000714_44E28000_00 +FFF80000_C9000000_00 +F800040E_CCFFFF7E_01 +00000013_41980000_00 +FFFC0000_C8800000_00 +F83BFFFF_CCF88000_01 +FFF3F584_C940A7C0_00 +FFFE0000_C8000000_00 +F6FFFBFF_CD100040_01 +FFFFFFF0_C1800000_00 +FFFF0000_C7800000_00 +80003FFD_CEFFFF80_01 +FFFFFFAD_C2A60000_00 +FFFF8000_C7000000_00 +004001FD_4A8003FA_00 +000D734E_495734E0_00 +FFFFC000_C6800000_00 +006003FE_4AC007FC_00 +FF9DBAA8_CAC48AB0_00 +FFFFE000_C6000000_00 +000403EE_48807DC0_00 +00734668_4AE68CD0_00 +FFFFF000_C5800000_00 +01200002_4B900001_00 +FF8874A5_CAEF16B6_00 +FFFFF800_C5000000_00 +00060001_48C00020_00 +FFFFFFF8_C1000000_00 +FFFFFC00_C4800000_00 +001FFEDD_49FFF6E8_00 +FFFC56DF_C86A4840_00 +FFFFFE00_C4000000_00 +EFFFEFFD_CD800080_01 +FECF5EC6_CB98509D_00 +FFFFFF00_C3800000_00 +1FF00002_4DFF8001_01 +F6DB786B_CD124879_01 +FFFFFF80_C3000000_00 +F0000FBE_CD7FFF04_01 +00000009_41100000_00 +FFFFFFC0_C2800000_00 +0010801F_498400F8_00 +0001F238_47F91C00_00 +FFFFFFE0_C2000000_00 +F8000047_CCFFFFF7_01 +0002133C_4804CF00_00 +FFFFFFF0_C1800000_00 +003C001F_4A70007C_00 +000001F1_43F88000_00 +FFFFFFF8_C1000000_00 +FFDFBFFF_CA010004_00 +FF5E507F_CB21AF81_00 +FFFFFFFC_C0800000_00 +037FFFDE_4C5FFFF8_01 +FFFD7C6F_C820E440_00 +FFFFFFFE_C0000000_00 +000000FD_437D0000_00 +FFFFF42A_C53D6000_00 +FFFFFFFF_BF800000_00 +021FFF7D_4C07FFE0_01 +0000000A_41200000_00 +FFFFFFFD_C0400000_00 +4010FFFF_4E802200_01 +FFFFFFD3_C2340000_00 +FFFFFFFB_C0A00000_00 +FFFF800B_C6FFEA00_00 +000000B8_43380000_00 +FFFFFFF7_C1100000_00 +FF800803_CAFFEFFA_00 +FFFFFFFE_C0000000_00 +FFFFFFEF_C1880000_00 +00803FFB_4B003FFB_00 +00000308_44420000_00 +FFFFFFDF_C2040000_00 +2107FFFE_4E042000_01 +FFE15D4F_C9F51588_00 +FFFFFFBF_C2820000_00 +400087FD_4E800110_01 +0000000F_41700000_00 +FFFFFF7F_C3010000_00 +FDFC007E_CC00FFE0_01 +00000006_40C00000_00 +FFFFFEFF_C3808000_00 +FFF80100_C8FFE000_00 +FFFFFE99_C3B38000_00 +FFFFFDFF_C4004000_00 +03000002_4C400001_01 +FFF716EA_C90E9160_00 +FFFFFBFF_C4802000_00 +C7FDFFFF_CE600800_01 +FFFFE327_C5E6C800_00 +FFFFF7FF_C5001000_00 +0103DFFE_4B81EFFF_00 +07661FD8_4CECC3FB_00 +FFFFEFFF_C5800800_00 +83FFFFFE_CEF80000_01 +FCD956DB_CC49AA49_01 +FFFFDFFF_C6000400_00 +FF2001FD_CB5FFE03_00 +E4D35BBF_CDD96522_01 +FFFFBFFF_C6800200_00 +DFEFEFFE_CE004040_01 +05DA4300_4CBB4860_00 +FFFF7FFF_C7000100_00 +40001040_4E800021_01 +812EDF40_CEFDA241_01 +FFFEFFFF_C7800080_00 +FFFFC007_C67FE400_00 +00B6FCC9_4B36FCC9_00 +FFFDFFFF_C8000040_00 +000007FE_44FFC000_00 +FC3DE950_CC7085AC_00 +FFFBFFFF_C8800020_00 +7FFFFE03_4EFFFFFD_01 +FEB02B59_CBA7EA53_01 +FFF7FFFF_C9000010_00 +10FF7FFF_4D87FC00_01 +00008D5E_470D5E00_00 +FFEFFFFF_C9800008_00 +FFFF007E_C77F8200_00 +001C2108_49E10840_00 +FFDFFFFF_CA000004_00 +00FFC001_4B7FC001_00 +F01C6B36_CD7E394C_01 +FFBFFFFF_CA800002_00 +FFFF7FFF_C7000100_00 +FFFFD055_C63EAC00_00 +FF7FFFFF_CB000001_00 +027BFFFE_4C1F0000_01 +FF3090D0_CB4F6F30_00 +FEFFFFFF_CB800000_01 +00082040_49020400_00 +0000006E_42DC0000_00 +FDFFFFFF_CC000000_01 +FDFFFF87_CC00001E_01 +04C3764D_4C986ECA_01 +FBFFFFFF_CC800000_01 +0006007E_48C00FC0_00 +000001EF_43F78000_00 +F7FFFFFF_CD000000_01 +FFBF7FFE_CA810004_00 +FF1C4E5A_CB63B1A6_00 +EFFFFFFF_CD800000_01 +FFF97FFD_C8D00060_00 +000001D1_43E88000_00 +DFFFFFFF_CE000000_01 +2FFFFFFE_4E400000_01 +00136721_499B3908_00 +BFFFFFFF_CE800000_01 +00004BFF_4697FE00_00 +00000544_44A88000_00 +7FFFFFFF_4F000000_01 +007FDFFB_4AFFBFF6_00 +FFF8BD5E_C8E85440_00 +3FFFFFFF_4E800000_01 +FFBF8003_CA80FFFA_00 +FFFE45D2_C7DD1700_00 +1FFFFFFF_4E000000_01 +FFFFFDBF_C4104000_00 +FFFFF189_C5677000_00 +0FFFFFFF_4D800000_01 +FFFE6FFE_C7C80100_00 +FC8672A0_CC5E6358_00 +07FFFFFF_4D000000_01 +00000107_43838000_00 +FFFCCA70_C84D6400_00 +03FFFFFF_4C800000_01 +002107FE_4A041FF8_00 +FFFF48E7_C7371900_00 +01FFFFFF_4C000000_01 +F7FDFFEE_CD002001_01 +00000010_41800000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_C77E0300_00 +0000FAEF_477AEF00_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000000F5_43750000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_C9FC0200_00 +001AFFFB_49D7FFD8_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +FF4613B2_CB39EC4E_00 +000FFFFF_497FFFF0_00 +F00005FE_CD7FFFA0_01 +00036402_48590080_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C80A000_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_C43F8000_00 +FFFF41C6_C73E3A00_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D4_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +FFFFFFFB_C0A00000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_CBC01001_00 +FFFFFFFD_C0400000_00 +00003FFF_467FFC00_00 +DBBFFFFE_CE110000_01 +00000404_44808000_00 +00001FFF_45FFF800_00 +FFFFC018_C67FA000_00 +00002853_46214C00_00 +00000FFF_457FF000_00 +03FE007F_4C7F8020_01 +FFFFF124_C56DC000_00 +000007FF_44FFE000_00 +FFFFEFBE_C5821000_00 +FFFB9AD8_C88CA500_00 +000003FF_447FC000_00 +DFFFFDFE_CE000008_01 +FFFFFD95_C41AC000_00 +000001FF_43FF8000_00 +FDFFFFFF_CC000000_01 +FFFFFFD0_C2400000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +010EC496_4B87624B_00 +0000007F_42FE0000_00 +B8007FFF_CE8FFF00_01 +00000012_41900000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +FFFFFFEF_C1880000_00 +0000001F_41F80000_00 +FF7FFF02_CB0000FE_00 +FFFFE2CE_C5E99000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +FFFFFE44_C3DE0000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +000038E7_46639C00_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f32_rz.tv b/wally-pipelined/testbench/fp/i32_f32_rz.tv index 7aa7eb823..ff8a0518c 100644 --- a/wally-pipelined/testbench/fp/i32_f32_rz.tv +++ b/wally-pipelined/testbench/fp/i32_f32_rz.tv @@ -1,372 +1,372 @@ -1FEFFFEF 4DFF7FFF_01 -FFFFC48E C66DC800_00 -00000000 00000000_00 -007FFFCD 4AFFFF9A_00 -00009E14 471E1400_00 -00000001 3F800000_00 -001FFFFB 49FFFFD8_00 -FFFFDE38 C6072000_00 -00000002 40000000_00 -FFDFFC02 CA000FF8_00 -FB794C79 CC90D670_01 -00000004 40800000_00 -F00FFFFE CD7F0000_01 -00000A95 45295000_00 -00000008 41000000_00 -FFFFF97F C4D02000_00 -FFAE458D CAA374E6_00 -00000010 41800000_00 -0101001E 4B80800F_00 -29EB4561 4E27AD15_01 -00000020 42000000_00 -8001FFEE CEFFFC00_01 -FFFBDD08 C8845F00_00 -00000040 42800000_00 -FFF03FF9 C97C0070_00 -FFCEDF36 CA448328_00 -00000080 43000000_00 -0000F01F 47701F00_00 -00000279 441E4000_00 -00000100 43800000_00 -BFFFFFEF CE800000_01 -00000007 40E00000_00 -00000200 44000000_00 -010BFFFD 4B85FFFE_01 -FFFFF590 C5270000_00 -00000400 44800000_00 -F7FFFEFB CD000010_01 -2FEA335F 4E3FA8CD_01 -00000800 45000000_00 -FFC07FFF CA7E0004_00 -177957FD 4DBBCABF_01 -00001000 45800000_00 -01FBFFEE 4BFDFFF7_00 -FFFFFAC9 C4A6E000_00 -00002000 46000000_00 -FFFF8004 C6FFF800_00 -FFFBE0DE C883E440_00 -00004000 46800000_00 -3F00001E 4E7C0000_01 -00000000 00000000_00 -00008000 47000000_00 -FF8201FF CAFBFC02_00 -FFFFD2F1 C6343C00_00 -00010000 47800000_00 -0000047E 448FC000_00 -0011B7E5 498DBF28_00 -00020000 48000000_00 -02200200 4C080080_00 -0013F7E6 499FBF30_00 -00040000 48800000_00 -FFFDC007 C80FFE40_00 -FD0ABD9A CC3D5099_01 -00080000 49000000_00 -0000607F 46C0FE00_00 -00003CEE 4673B800_00 -00100000 49800000_00 -DFDFE000 CE008080_00 -FFFB1642 C89D37C0_00 -00200000 4A000000_00 -FC000078 CC7FFFE2_00 -5F70EEC1 4EBEE1DD_01 -00400000 4A800000_00 -00100082 49800410_00 -FFFFFE21 C3EF8000_00 -00800000 4B000000_00 -FF7BFF7F CB040081_00 -FFFF6393 C71C6D00_00 -01000000 4B800000_00 -07EFFEFD 4CFDFFDF_01 -FFFFFDB4 C4130000_00 -02000000 4C000000_00 -8002FFFF CEFFFA00_01 -FFFFC8E2 C65C7800_00 -04000000 4C800000_00 -FFFC0DFE C87C8080_00 -FFFFFF1B C3650000_00 -08000000 4D000000_00 -03FFFDBF 4C7FFF6F_01 -0001092B 47849580_00 -10000000 4D800000_00 -007FBFFD 4AFF7FFA_00 -00B4F3D1 4B34F3D1_00 -20000000 4E000000_00 -FEF801FF CB83FF00_01 -00000005 40A00000_00 -40000000 4E800000_00 -BFF3FFFE CE801800_01 -0001806B 47C03580_00 -80000000 CF000000_00 -0000A07E 47207E00_00 -FFFFA59F C6B4C200_00 -C0000000 CE800000_00 -E0007FDE CDFFFC01_01 -FFF8343E C8F97840_00 -E0000000 CE000000_00 -0000FF7C 477F7C00_00 -FFFFFFF7 C1100000_00 -F0000000 CD800000_00 -BDFFFFFC CE840000_01 -FFFFE3C1 C5E1F800_00 -F8000000 CD000000_00 -28003FFE 4E2000FF_01 -00000000 00000000_00 -FC000000 CC800000_00 -00EEFFFF 4B6EFFFF_00 -00003EB0 467AC000_00 -FE000000 CC000000_00 -00000F7D 4577D000_00 -FFFFFF0F C3710000_00 -FF000000 CB800000_00 -0000406D 4680DA00_00 -0000001A 41D00000_00 -FF800000 CB000000_00 -203FFFFD 4E00FFFF_01 -0000000A 41200000_00 -FFC00000 CA800000_00 -FFFF007C C77F8400_00 -0000009B 431B0000_00 -FFE00000 CA000000_00 -00E00FFF 4B600FFF_00 -00000006 40C00000_00 -FFF00000 C9800000_00 -00200FFC 4A003FF0_00 -00000714 44E28000_00 -FFF80000 C9000000_00 -F800040E CCFFFF7E_01 -00000013 41980000_00 -FFFC0000 C8800000_00 -F83BFFFF CCF88000_01 -FFF3F584 C940A7C0_00 -FFFE0000 C8000000_00 -F6FFFBFF CD100040_01 -FFFFFFF0 C1800000_00 -FFFF0000 C7800000_00 -80003FFD CEFFFF80_01 -FFFFFFAD C2A60000_00 -FFFF8000 C7000000_00 -004001FD 4A8003FA_00 -000D734E 495734E0_00 -FFFFC000 C6800000_00 -006003FE 4AC007FC_00 -FF9DBAA8 CAC48AB0_00 -FFFFE000 C6000000_00 -000403EE 48807DC0_00 -00734668 4AE68CD0_00 -FFFFF000 C5800000_00 -01200002 4B900001_00 -FF8874A5 CAEF16B6_00 -FFFFF800 C5000000_00 -00060001 48C00020_00 -FFFFFFF8 C1000000_00 -FFFFFC00 C4800000_00 -001FFEDD 49FFF6E8_00 -FFFC56DF C86A4840_00 -FFFFFE00 C4000000_00 -EFFFEFFD CD800080_01 -FECF5EC6 CB98509D_00 -FFFFFF00 C3800000_00 -1FF00002 4DFF8000_01 -F6DB786B CD124879_01 -FFFFFF80 C3000000_00 -F0000FBE CD7FFF04_01 -00000009 41100000_00 -FFFFFFC0 C2800000_00 -0010801F 498400F8_00 -0001F238 47F91C00_00 -FFFFFFE0 C2000000_00 -F8000047 CCFFFFF7_01 -0002133C 4804CF00_00 -FFFFFFF0 C1800000_00 -003C001F 4A70007C_00 -000001F1 43F88000_00 -FFFFFFF8 C1000000_00 -FFDFBFFF CA010004_00 -FF5E507F CB21AF81_00 -FFFFFFFC C0800000_00 -037FFFDE 4C5FFFF7_01 -FFFD7C6F C820E440_00 -FFFFFFFE C0000000_00 -000000FD 437D0000_00 -FFFFF42A C53D6000_00 -FFFFFFFF BF800000_00 -021FFF7D 4C07FFDF_01 -0000000A 41200000_00 -FFFFFFFD C0400000_00 -4010FFFF 4E8021FF_01 -FFFFFFD3 C2340000_00 -FFFFFFFB C0A00000_00 -FFFF800B C6FFEA00_00 -000000B8 43380000_00 -FFFFFFF7 C1100000_00 -FF800803 CAFFEFFA_00 -FFFFFFFE C0000000_00 -FFFFFFEF C1880000_00 -00803FFB 4B003FFB_00 -00000308 44420000_00 -FFFFFFDF C2040000_00 -2107FFFE 4E041FFF_01 -FFE15D4F C9F51588_00 -FFFFFFBF C2820000_00 -400087FD 4E80010F_01 -0000000F 41700000_00 -FFFFFF7F C3010000_00 -FDFC007E CC00FFE0_01 -00000006 40C00000_00 -FFFFFEFF C3808000_00 -FFF80100 C8FFE000_00 -FFFFFE99 C3B38000_00 -FFFFFDFF C4004000_00 -03000002 4C400000_01 -FFF716EA C90E9160_00 -FFFFFBFF C4802000_00 -C7FDFFFF CE600800_01 -FFFFE327 C5E6C800_00 -FFFFF7FF C5001000_00 -0103DFFE 4B81EFFF_00 -07661FD8 4CECC3FB_00 -FFFFEFFF C5800800_00 -83FFFFFE CEF80000_01 -FCD956DB CC49AA49_01 -FFFFDFFF C6000400_00 -FF2001FD CB5FFE03_00 -E4D35BBF CDD96522_01 -FFFFBFFF C6800200_00 -DFEFEFFE CE004040_01 -05DA4300 4CBB4860_00 -FFFF7FFF C7000100_00 -40001040 4E800020_01 -812EDF40 CEFDA241_01 -FFFEFFFF C7800080_00 -FFFFC007 C67FE400_00 -00B6FCC9 4B36FCC9_00 -FFFDFFFF C8000040_00 -000007FE 44FFC000_00 -FC3DE950 CC7085AC_00 -FFFBFFFF C8800020_00 -7FFFFE03 4EFFFFFC_01 -FEB02B59 CBA7EA53_01 -FFF7FFFF C9000010_00 -10FF7FFF 4D87FBFF_01 -00008D5E 470D5E00_00 -FFEFFFFF C9800008_00 -FFFF007E C77F8200_00 -001C2108 49E10840_00 -FFDFFFFF CA000004_00 -00FFC001 4B7FC001_00 -F01C6B36 CD7E394C_01 -FFBFFFFF CA800002_00 -FFFF7FFF C7000100_00 -FFFFD055 C63EAC00_00 -FF7FFFFF CB000001_00 -027BFFFE 4C1EFFFF_01 -FF3090D0 CB4F6F30_00 -FEFFFFFF CB800000_01 -00082040 49020400_00 -0000006E 42DC0000_00 -FDFFFFFF CC000000_01 -FDFFFF87 CC00001E_01 -04C3764D 4C986EC9_01 -FBFFFFFF CC800000_01 -0006007E 48C00FC0_00 -000001EF 43F78000_00 -F7FFFFFF CD000000_01 -FFBF7FFE CA810004_00 -FF1C4E5A CB63B1A6_00 -EFFFFFFF CD800000_01 -FFF97FFD C8D00060_00 -000001D1 43E88000_00 -DFFFFFFF CE000000_01 -2FFFFFFE 4E3FFFFF_01 -00136721 499B3908_00 -BFFFFFFF CE800000_01 -00004BFF 4697FE00_00 -00000544 44A88000_00 -7FFFFFFF 4EFFFFFF_01 -007FDFFB 4AFFBFF6_00 -FFF8BD5E C8E85440_00 -3FFFFFFF 4E7FFFFF_01 -FFBF8003 CA80FFFA_00 -FFFE45D2 C7DD1700_00 -1FFFFFFF 4DFFFFFF_01 -FFFFFDBF C4104000_00 -FFFFF189 C5677000_00 -0FFFFFFF 4D7FFFFF_01 -FFFE6FFE C7C80100_00 -FC8672A0 CC5E6358_00 -07FFFFFF 4CFFFFFF_01 -00000107 43838000_00 -FFFCCA70 C84D6400_00 -03FFFFFF 4C7FFFFF_01 -002107FE 4A041FF8_00 -FFFF48E7 C7371900_00 -01FFFFFF 4BFFFFFF_01 -F7FDFFEE CD002001_01 -00000010 41800000_00 -00FFFFFF 4B7FFFFF_00 -FFFF01FD C77E0300_00 -0000FAEF 477AEF00_00 -007FFFFF 4AFFFFFE_00 -00FC0001 4B7C0001_00 -000000F5 43750000_00 -003FFFFF 4A7FFFFC_00 -FFE07FC0 C9FC0200_00 -001AFFFB 49D7FFD8_00 -001FFFFF 49FFFFF8_00 -00101FFD 4980FFE8_00 -FF4613B2 CB39EC4E_00 -000FFFFF 497FFFF0_00 -F00005FE CD7FFFA0_01 -00036402 48590080_00 -0007FFFF 48FFFFE0_00 -0404FFFF 4C809FFF_01 -021C2358 4C0708D6_00 -0003FFFF 487FFFC0_00 -FFFFFD02 C43F8000_00 -FFFF41C6 C73E3A00_00 -0001FFFF 47FFFF80_00 -00000007 40E00000_00 -27F174DE 4E1FC5D3_01 -0000FFFF 477FFF00_00 -000083F5 4703F500_00 -FFFFFFFB C0A00000_00 -00007FFF 46FFFE00_00 -FE7FDFFE CBC01001_00 -FFFFFFFD C0400000_00 -00003FFF 467FFC00_00 -DBBFFFFE CE110000_01 -00000404 44808000_00 -00001FFF 45FFF800_00 -FFFFC018 C67FA000_00 -00002853 46214C00_00 -00000FFF 457FF000_00 -03FE007F 4C7F801F_01 -FFFFF124 C56DC000_00 -000007FF 44FFE000_00 -FFFFEFBE C5821000_00 -FFFB9AD8 C88CA500_00 -000003FF 447FC000_00 -DFFFFDFE CE000008_01 -FFFFFD95 C41AC000_00 -000001FF 43FF8000_00 -FDFFFFFF CC000000_01 -FFFFFFD0 C2400000_00 -000000FF 437F0000_00 -0037FFE0 4A5FFF80_00 -010EC496 4B87624B_00 -0000007F 42FE0000_00 -B8007FFF CE8FFF00_01 -00000012 41900000_00 -0000003F 427C0000_00 -02003FFC 4C000FFF_00 -FFFFFFEF C1880000_00 -0000001F 41F80000_00 -FF7FFF02 CB0000FE_00 -FFFFE2CE C5E99000_00 -0000000F 41700000_00 -0000A00D 47200D00_00 -FFFFFE44 C3DE0000_00 -00000007 40E00000_00 -0003FFFA 487FFE80_00 -000038E7 46639C00_00 -00000003 40400000_00 +1FEFFFEF_4DFF7FFF_01 +FFFFC48E_C66DC800_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00009E14_471E1400_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +FFFFDE38_C6072000_00 +00000002_40000000_00 +FFDFFC02_CA000FF8_00 +FB794C79_CC90D670_01 +00000004_40800000_00 +F00FFFFE_CD7F0000_01 +00000A95_45295000_00 +00000008_41000000_00 +FFFFF97F_C4D02000_00 +FFAE458D_CAA374E6_00 +00000010_41800000_00 +0101001E_4B80800F_00 +29EB4561_4E27AD15_01 +00000020_42000000_00 +8001FFEE_CEFFFC00_01 +FFFBDD08_C8845F00_00 +00000040_42800000_00 +FFF03FF9_C97C0070_00 +FFCEDF36_CA448328_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000279_441E4000_00 +00000100_43800000_00 +BFFFFFEF_CE800000_01 +00000007_40E00000_00 +00000200_44000000_00 +010BFFFD_4B85FFFE_01 +FFFFF590_C5270000_00 +00000400_44800000_00 +F7FFFEFB_CD000010_01 +2FEA335F_4E3FA8CD_01 +00000800_45000000_00 +FFC07FFF_CA7E0004_00 +177957FD_4DBBCABF_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +FFFFFAC9_C4A6E000_00 +00002000_46000000_00 +FFFF8004_C6FFF800_00 +FFFBE0DE_C883E440_00 +00004000_46800000_00 +3F00001E_4E7C0000_01 +00000000_00000000_00 +00008000_47000000_00 +FF8201FF_CAFBFC02_00 +FFFFD2F1_C6343C00_00 +00010000_47800000_00 +0000047E_448FC000_00 +0011B7E5_498DBF28_00 +00020000_48000000_00 +02200200_4C080080_00 +0013F7E6_499FBF30_00 +00040000_48800000_00 +FFFDC007_C80FFE40_00 +FD0ABD9A_CC3D5099_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00003CEE_4673B800_00 +00100000_49800000_00 +DFDFE000_CE008080_00 +FFFB1642_C89D37C0_00 +00200000_4A000000_00 +FC000078_CC7FFFE2_00 +5F70EEC1_4EBEE1DD_01 +00400000_4A800000_00 +00100082_49800410_00 +FFFFFE21_C3EF8000_00 +00800000_4B000000_00 +FF7BFF7F_CB040081_00 +FFFF6393_C71C6D00_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFDF_01 +FFFFFDB4_C4130000_00 +02000000_4C000000_00 +8002FFFF_CEFFFA00_01 +FFFFC8E2_C65C7800_00 +04000000_4C800000_00 +FFFC0DFE_C87C8080_00 +FFFFFF1B_C3650000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF6F_01 +0001092B_47849580_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +00B4F3D1_4B34F3D1_00 +20000000_4E000000_00 +FEF801FF_CB83FF00_01 +00000005_40A00000_00 +40000000_4E800000_00 +BFF3FFFE_CE801800_01 +0001806B_47C03580_00 +80000000_CF000000_00 +0000A07E_47207E00_00 +FFFFA59F_C6B4C200_00 +C0000000_CE800000_00 +E0007FDE_CDFFFC01_01 +FFF8343E_C8F97840_00 +E0000000_CE000000_00 +0000FF7C_477F7C00_00 +FFFFFFF7_C1100000_00 +F0000000_CD800000_00 +BDFFFFFC_CE840000_01 +FFFFE3C1_C5E1F800_00 +F8000000_CD000000_00 +28003FFE_4E2000FF_01 +00000000_00000000_00 +FC000000_CC800000_00 +00EEFFFF_4B6EFFFF_00 +00003EB0_467AC000_00 +FE000000_CC000000_00 +00000F7D_4577D000_00 +FFFFFF0F_C3710000_00 +FF000000_CB800000_00 +0000406D_4680DA00_00 +0000001A_41D00000_00 +FF800000_CB000000_00 +203FFFFD_4E00FFFF_01 +0000000A_41200000_00 +FFC00000_CA800000_00 +FFFF007C_C77F8400_00 +0000009B_431B0000_00 +FFE00000_CA000000_00 +00E00FFF_4B600FFF_00 +00000006_40C00000_00 +FFF00000_C9800000_00 +00200FFC_4A003FF0_00 +00000714_44E28000_00 +FFF80000_C9000000_00 +F800040E_CCFFFF7E_01 +00000013_41980000_00 +FFFC0000_C8800000_00 +F83BFFFF_CCF88000_01 +FFF3F584_C940A7C0_00 +FFFE0000_C8000000_00 +F6FFFBFF_CD100040_01 +FFFFFFF0_C1800000_00 +FFFF0000_C7800000_00 +80003FFD_CEFFFF80_01 +FFFFFFAD_C2A60000_00 +FFFF8000_C7000000_00 +004001FD_4A8003FA_00 +000D734E_495734E0_00 +FFFFC000_C6800000_00 +006003FE_4AC007FC_00 +FF9DBAA8_CAC48AB0_00 +FFFFE000_C6000000_00 +000403EE_48807DC0_00 +00734668_4AE68CD0_00 +FFFFF000_C5800000_00 +01200002_4B900001_00 +FF8874A5_CAEF16B6_00 +FFFFF800_C5000000_00 +00060001_48C00020_00 +FFFFFFF8_C1000000_00 +FFFFFC00_C4800000_00 +001FFEDD_49FFF6E8_00 +FFFC56DF_C86A4840_00 +FFFFFE00_C4000000_00 +EFFFEFFD_CD800080_01 +FECF5EC6_CB98509D_00 +FFFFFF00_C3800000_00 +1FF00002_4DFF8000_01 +F6DB786B_CD124879_01 +FFFFFF80_C3000000_00 +F0000FBE_CD7FFF04_01 +00000009_41100000_00 +FFFFFFC0_C2800000_00 +0010801F_498400F8_00 +0001F238_47F91C00_00 +FFFFFFE0_C2000000_00 +F8000047_CCFFFFF7_01 +0002133C_4804CF00_00 +FFFFFFF0_C1800000_00 +003C001F_4A70007C_00 +000001F1_43F88000_00 +FFFFFFF8_C1000000_00 +FFDFBFFF_CA010004_00 +FF5E507F_CB21AF81_00 +FFFFFFFC_C0800000_00 +037FFFDE_4C5FFFF7_01 +FFFD7C6F_C820E440_00 +FFFFFFFE_C0000000_00 +000000FD_437D0000_00 +FFFFF42A_C53D6000_00 +FFFFFFFF_BF800000_00 +021FFF7D_4C07FFDF_01 +0000000A_41200000_00 +FFFFFFFD_C0400000_00 +4010FFFF_4E8021FF_01 +FFFFFFD3_C2340000_00 +FFFFFFFB_C0A00000_00 +FFFF800B_C6FFEA00_00 +000000B8_43380000_00 +FFFFFFF7_C1100000_00 +FF800803_CAFFEFFA_00 +FFFFFFFE_C0000000_00 +FFFFFFEF_C1880000_00 +00803FFB_4B003FFB_00 +00000308_44420000_00 +FFFFFFDF_C2040000_00 +2107FFFE_4E041FFF_01 +FFE15D4F_C9F51588_00 +FFFFFFBF_C2820000_00 +400087FD_4E80010F_01 +0000000F_41700000_00 +FFFFFF7F_C3010000_00 +FDFC007E_CC00FFE0_01 +00000006_40C00000_00 +FFFFFEFF_C3808000_00 +FFF80100_C8FFE000_00 +FFFFFE99_C3B38000_00 +FFFFFDFF_C4004000_00 +03000002_4C400000_01 +FFF716EA_C90E9160_00 +FFFFFBFF_C4802000_00 +C7FDFFFF_CE600800_01 +FFFFE327_C5E6C800_00 +FFFFF7FF_C5001000_00 +0103DFFE_4B81EFFF_00 +07661FD8_4CECC3FB_00 +FFFFEFFF_C5800800_00 +83FFFFFE_CEF80000_01 +FCD956DB_CC49AA49_01 +FFFFDFFF_C6000400_00 +FF2001FD_CB5FFE03_00 +E4D35BBF_CDD96522_01 +FFFFBFFF_C6800200_00 +DFEFEFFE_CE004040_01 +05DA4300_4CBB4860_00 +FFFF7FFF_C7000100_00 +40001040_4E800020_01 +812EDF40_CEFDA241_01 +FFFEFFFF_C7800080_00 +FFFFC007_C67FE400_00 +00B6FCC9_4B36FCC9_00 +FFFDFFFF_C8000040_00 +000007FE_44FFC000_00 +FC3DE950_CC7085AC_00 +FFFBFFFF_C8800020_00 +7FFFFE03_4EFFFFFC_01 +FEB02B59_CBA7EA53_01 +FFF7FFFF_C9000010_00 +10FF7FFF_4D87FBFF_01 +00008D5E_470D5E00_00 +FFEFFFFF_C9800008_00 +FFFF007E_C77F8200_00 +001C2108_49E10840_00 +FFDFFFFF_CA000004_00 +00FFC001_4B7FC001_00 +F01C6B36_CD7E394C_01 +FFBFFFFF_CA800002_00 +FFFF7FFF_C7000100_00 +FFFFD055_C63EAC00_00 +FF7FFFFF_CB000001_00 +027BFFFE_4C1EFFFF_01 +FF3090D0_CB4F6F30_00 +FEFFFFFF_CB800000_01 +00082040_49020400_00 +0000006E_42DC0000_00 +FDFFFFFF_CC000000_01 +FDFFFF87_CC00001E_01 +04C3764D_4C986EC9_01 +FBFFFFFF_CC800000_01 +0006007E_48C00FC0_00 +000001EF_43F78000_00 +F7FFFFFF_CD000000_01 +FFBF7FFE_CA810004_00 +FF1C4E5A_CB63B1A6_00 +EFFFFFFF_CD800000_01 +FFF97FFD_C8D00060_00 +000001D1_43E88000_00 +DFFFFFFF_CE000000_01 +2FFFFFFE_4E3FFFFF_01 +00136721_499B3908_00 +BFFFFFFF_CE800000_01 +00004BFF_4697FE00_00 +00000544_44A88000_00 +7FFFFFFF_4EFFFFFF_01 +007FDFFB_4AFFBFF6_00 +FFF8BD5E_C8E85440_00 +3FFFFFFF_4E7FFFFF_01 +FFBF8003_CA80FFFA_00 +FFFE45D2_C7DD1700_00 +1FFFFFFF_4DFFFFFF_01 +FFFFFDBF_C4104000_00 +FFFFF189_C5677000_00 +0FFFFFFF_4D7FFFFF_01 +FFFE6FFE_C7C80100_00 +FC8672A0_CC5E6358_00 +07FFFFFF_4CFFFFFF_01 +00000107_43838000_00 +FFFCCA70_C84D6400_00 +03FFFFFF_4C7FFFFF_01 +002107FE_4A041FF8_00 +FFFF48E7_C7371900_00 +01FFFFFF_4BFFFFFF_01 +F7FDFFEE_CD002001_01 +00000010_41800000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_C77E0300_00 +0000FAEF_477AEF00_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000000F5_43750000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_C9FC0200_00 +001AFFFB_49D7FFD8_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +FF4613B2_CB39EC4E_00 +000FFFFF_497FFFF0_00 +F00005FE_CD7FFFA0_01 +00036402_48590080_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C809FFF_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_C43F8000_00 +FFFF41C6_C73E3A00_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D3_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +FFFFFFFB_C0A00000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_CBC01001_00 +FFFFFFFD_C0400000_00 +00003FFF_467FFC00_00 +DBBFFFFE_CE110000_01 +00000404_44808000_00 +00001FFF_45FFF800_00 +FFFFC018_C67FA000_00 +00002853_46214C00_00 +00000FFF_457FF000_00 +03FE007F_4C7F801F_01 +FFFFF124_C56DC000_00 +000007FF_44FFE000_00 +FFFFEFBE_C5821000_00 +FFFB9AD8_C88CA500_00 +000003FF_447FC000_00 +DFFFFDFE_CE000008_01 +FFFFFD95_C41AC000_00 +000001FF_43FF8000_00 +FDFFFFFF_CC000000_01 +FFFFFFD0_C2400000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +010EC496_4B87624B_00 +0000007F_42FE0000_00 +B8007FFF_CE8FFF00_01 +00000012_41900000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +FFFFFFEF_C1880000_00 +0000001F_41F80000_00 +FF7FFF02_CB0000FE_00 +FFFFE2CE_C5E99000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +FFFFFE44_C3DE0000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +000038E7_46639C00_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_rd.tv b/wally-pipelined/testbench/fp/i32_f64_rd.tv index 7f04b63fd..3e4622082 100644 --- a/wally-pipelined/testbench/fp/i32_f64_rd.tv +++ b/wally-pipelined/testbench/fp/i32_f64_rd.tv @@ -1,372 +1,372 @@ -1FEFFFEF 41BFEFFFEF000000_00 -FFFFC48E C0CDB90000000000_00 -00000000 0000000000000000_00 -007FFFCD 415FFFF340000000_00 -00009E14 40E3C28000000000_00 -00000001 3FF0000000000000_00 -001FFFFB 413FFFFB00000000_00 -FFFFDE38 C0C0E40000000000_00 -00000002 4000000000000000_00 -FFDFFC02 C14001FF00000000_00 -FB794C79 C1921ACE1C000000_00 -00000004 4010000000000000_00 -F00FFFFE C1AFE00004000000_00 -00000A95 40A52A0000000000_00 -00000008 4020000000000000_00 -FFFFF97F C09A040000000000_00 -FFAE458D C1546E9CC0000000_00 -00000010 4030000000000000_00 -0101001E 41701001E0000000_00 -29EB4561 41C4F5A2B0800000_00 -00000020 4040000000000000_00 -8001FFEE C1DFFF8004800000_00 -FFFBDD08 C1108BE000000000_00 -00000040 4050000000000000_00 -FFF03FF9 C12F800E00000000_00 -FFCEDF36 C148906500000000_00 -00000080 4060000000000000_00 -0000F01F 40EE03E000000000_00 -00000279 4083C80000000000_00 -00000100 4070000000000000_00 -BFFFFFEF C1D0000004400000_00 -00000007 401C000000000000_00 -00000200 4080000000000000_00 -010BFFFD 4170BFFFD0000000_00 -FFFFF590 C0A4E00000000000_00 -00000400 4090000000000000_00 -F7FFFEFB C1A000020A000000_00 -2FEA335F 41C7F519AF800000_00 -00000800 40A0000000000000_00 -FFC07FFF C14FC00080000000_00 -177957FD 41B77957FD000000_00 -00001000 40B0000000000000_00 -01FBFFEE 417FBFFEE0000000_00 -FFFFFAC9 C094DC0000000000_00 -00002000 40C0000000000000_00 -FFFF8004 C0DFFF0000000000_00 -FFFBE0DE C1107C8800000000_00 -00004000 40D0000000000000_00 -3F00001E 41CF80000F000000_00 -00000000 0000000000000000_00 -00008000 40E0000000000000_00 -FF8201FF C15F7F8040000000_00 -FFFFD2F1 C0C6878000000000_00 -00010000 40F0000000000000_00 -0000047E 4091F80000000000_00 -0011B7E5 4131B7E500000000_00 -00020000 4100000000000000_00 -02200200 4181001000000000_00 -0013F7E6 4133F7E600000000_00 -00040000 4110000000000000_00 -FFFDC007 C101FFC800000000_00 -FD0ABD9A C187AA1330000000_00 -00080000 4120000000000000_00 -0000607F 40D81FC000000000_00 -00003CEE 40CE770000000000_00 -00100000 4130000000000000_00 -DFDFE000 C1C0101000000000_00 -FFFB1642 C113A6F800000000_00 -00200000 4140000000000000_00 -FC000078 C18FFFFC40000000_00 -5F70EEC1 41D7DC3BB0400000_00 -00400000 4150000000000000_00 -00100082 4130008200000000_00 -FFFFFE21 C07DF00000000000_00 -00800000 4160000000000000_00 -FF7BFF7F C160801020000000_00 -FFFF6393 C0E38DA000000000_00 -01000000 4170000000000000_00 -07EFFEFD 419FBFFBF4000000_00 -FFFFFDB4 C082600000000000_00 -02000000 4180000000000000_00 -8002FFFF C1DFFF4000400000_00 -FFFFC8E2 C0CB8F0000000000_00 -04000000 4190000000000000_00 -FFFC0DFE C10F901000000000_00 -FFFFFF1B C06CA00000000000_00 -08000000 41A0000000000000_00 -03FFFDBF 418FFFEDF8000000_00 -0001092B 40F092B000000000_00 -10000000 41B0000000000000_00 -007FBFFD 415FEFFF40000000_00 -00B4F3D1 41669E7A20000000_00 -20000000 41C0000000000000_00 -FEF801FF C1707FE010000000_00 -00000005 4014000000000000_00 -40000000 41D0000000000000_00 -BFF3FFFE C1D0030000800000_00 -0001806B 40F806B000000000_00 -80000000 C1E0000000000000_00 -0000A07E 40E40FC000000000_00 -FFFFA59F C0D6984000000000_00 -C0000000 C1D0000000000000_00 -E0007FDE C1BFFF8022000000_00 -FFF8343E C11F2F0800000000_00 -E0000000 C1C0000000000000_00 -0000FF7C 40EFEF8000000000_00 -FFFFFFF7 C022000000000000_00 -F0000000 C1B0000000000000_00 -BDFFFFFC C1D0800001000000_00 -FFFFE3C1 C0BC3F0000000000_00 -F8000000 C1A0000000000000_00 -28003FFE 41C4001FFF000000_00 -00000000 0000000000000000_00 -FC000000 C190000000000000_00 -00EEFFFF 416DDFFFE0000000_00 -00003EB0 40CF580000000000_00 -FE000000 C180000000000000_00 -00000F7D 40AEFA0000000000_00 -FFFFFF0F C06E200000000000_00 -FF000000 C170000000000000_00 -0000406D 40D01B4000000000_00 -0000001A 403A000000000000_00 -FF800000 C160000000000000_00 -203FFFFD 41C01FFFFE800000_00 -0000000A 4024000000000000_00 -FFC00000 C150000000000000_00 -FFFF007C C0EFF08000000000_00 -0000009B 4063600000000000_00 -FFE00000 C140000000000000_00 -00E00FFF 416C01FFE0000000_00 -00000006 4018000000000000_00 -FFF00000 C130000000000000_00 -00200FFC 414007FE00000000_00 -00000714 409C500000000000_00 -FFF80000 C120000000000000_00 -F800040E C19FFFEFC8000000_00 -00000013 4033000000000000_00 -FFFC0000 C110000000000000_00 -F83BFFFF C19F100004000000_00 -FFF3F584 C12814F800000000_00 -FFFE0000 C100000000000000_00 -F6FFFBFF C1A2000802000000_00 -FFFFFFF0 C030000000000000_00 -FFFF0000 C0F0000000000000_00 -80003FFD C1DFFFF000C00000_00 -FFFFFFAD C054C00000000000_00 -FFFF8000 C0E0000000000000_00 -004001FD 4150007F40000000_00 -000D734E 412AE69C00000000_00 -FFFFC000 C0D0000000000000_00 -006003FE 415800FF80000000_00 -FF9DBAA8 C158915600000000_00 -FFFFE000 C0C0000000000000_00 -000403EE 41100FB800000000_00 -00734668 415CD19A00000000_00 -FFFFF000 C0B0000000000000_00 -01200002 4172000020000000_00 -FF8874A5 C15DE2D6C0000000_00 -FFFFF800 C0A0000000000000_00 -00060001 4118000400000000_00 -FFFFFFF8 C020000000000000_00 -FFFFFC00 C090000000000000_00 -001FFEDD 413FFEDD00000000_00 -FFFC56DF C10D490800000000_00 -FFFFFE00 C080000000000000_00 -EFFFEFFD C1B0001003000000_00 -FECF5EC6 C1730A13A0000000_00 -FFFFFF00 C070000000000000_00 -1FF00002 41BFF00002000000_00 -F6DB786B C1A2490F2A000000_00 -FFFFFF80 C060000000000000_00 -F0000FBE C1AFFFE084000000_00 -00000009 4022000000000000_00 -FFFFFFC0 C050000000000000_00 -0010801F 4130801F00000000_00 -0001F238 40FF238000000000_00 -FFFFFFE0 C040000000000000_00 -F8000047 C19FFFFEE4000000_00 -0002133C 410099E000000000_00 -FFFFFFF0 C030000000000000_00 -003C001F 414E000F80000000_00 -000001F1 407F100000000000_00 -FFFFFFF8 C020000000000000_00 -FFDFBFFF C140200080000000_00 -FF5E507F C16435F020000000_00 -FFFFFFFC C010000000000000_00 -037FFFDE 418BFFFEF0000000_00 -FFFD7C6F C1041C8800000000_00 -FFFFFFFE C000000000000000_00 -000000FD 406FA00000000000_00 -FFFFF42A C0A7AC0000000000_00 -FFFFFFFF BFF0000000000000_00 -021FFF7D 4180FFFBE8000000_00 -0000000A 4024000000000000_00 -FFFFFFFD C008000000000000_00 -4010FFFF 41D0043FFFC00000_00 -FFFFFFD3 C046800000000000_00 -FFFFFFFB C014000000000000_00 -FFFF800B C0DFFD4000000000_00 -000000B8 4067000000000000_00 -FFFFFFF7 C022000000000000_00 -FF800803 C15FFDFF40000000_00 -FFFFFFFE C000000000000000_00 -FFFFFFEF C031000000000000_00 -00803FFB 416007FF60000000_00 -00000308 4088400000000000_00 -FFFFFFDF C040800000000000_00 -2107FFFE 41C083FFFF000000_00 -FFE15D4F C13EA2B100000000_00 -FFFFFFBF C050400000000000_00 -400087FD 41D00021FF400000_00 -0000000F 402E000000000000_00 -FFFFFF7F C060200000000000_00 -FDFC007E C1801FFC10000000_00 -00000006 4018000000000000_00 -FFFFFEFF C070100000000000_00 -FFF80100 C11FFC0000000000_00 -FFFFFE99 C076700000000000_00 -FFFFFDFF C080080000000000_00 -03000002 4188000010000000_00 -FFF716EA C121D22C00000000_00 -FFFFFBFF C090040000000000_00 -C7FDFFFF C1CC010000800000_00 -FFFFE327 C0BCD90000000000_00 -FFFFF7FF C0A0020000000000_00 -0103DFFE 41703DFFE0000000_00 -07661FD8 419D987F60000000_00 -FFFFEFFF C0B0010000000000_00 -83FFFFFE C1DF000000800000_00 -FCD956DB C189354928000000_00 -FFFFDFFF C0C0008000000000_00 -FF2001FD C16BFFC060000000_00 -E4D35BBF C1BB2CA441000000_00 -FFFFBFFF C0D0004000000000_00 -DFEFEFFE C1C0080801000000_00 -05DA4300 4197690C00000000_00 -FFFF7FFF C0E0002000000000_00 -40001040 41D0000410000000_00 -812EDF40 C1DFB44830000000_00 -FFFEFFFF C0F0001000000000_00 -FFFFC007 C0CFFC8000000000_00 -00B6FCC9 4166DF9920000000_00 -FFFDFFFF C100000800000000_00 -000007FE 409FF80000000000_00 -FC3DE950 C18E10B580000000_00 -FFFBFFFF C110000400000000_00 -7FFFFE03 41DFFFFF80C00000_00 -FEB02B59 C174FD4A70000000_00 -FFF7FFFF C120000200000000_00 -10FF7FFF 41B0FF7FFF000000_00 -00008D5E 40E1ABC000000000_00 -FFEFFFFF C130000100000000_00 -FFFF007E C0EFF04000000000_00 -001C2108 413C210800000000_00 -FFDFFFFF C140000080000000_00 -00FFC001 416FF80020000000_00 -F01C6B36 C1AFC72994000000_00 -FFBFFFFF C150000040000000_00 -FFFF7FFF C0E0002000000000_00 -FFFFD055 C0C7D58000000000_00 -FF7FFFFF C160000020000000_00 -027BFFFE 4183DFFFF0000000_00 -FF3090D0 C169EDE600000000_00 -FEFFFFFF C170000010000000_00 -00082040 4120408000000000_00 -0000006E 405B800000000000_00 -FDFFFFFF C180000008000000_00 -FDFFFF87 C1800003C8000000_00 -04C3764D 41930DD934000000_00 -FBFFFFFF C190000004000000_00 -0006007E 411801F800000000_00 -000001EF 407EF00000000000_00 -F7FFFFFF C1A0000002000000_00 -FFBF7FFE C150200080000000_00 -FF1C4E5A C16C7634C0000000_00 -EFFFFFFF C1B0000001000000_00 -FFF97FFD C11A000C00000000_00 -000001D1 407D100000000000_00 -DFFFFFFF C1C0000000800000_00 -2FFFFFFE 41C7FFFFFF000000_00 -00136721 4133672100000000_00 -BFFFFFFF C1D0000000400000_00 -00004BFF 40D2FFC000000000_00 -00000544 4095100000000000_00 -7FFFFFFF 41DFFFFFFFC00000_00 -007FDFFB 415FF7FEC0000000_00 -FFF8BD5E C11D0A8800000000_00 -3FFFFFFF 41CFFFFFFF800000_00 -FFBF8003 C1501FFF40000000_00 -FFFE45D2 C0FBA2E000000000_00 -1FFFFFFF 41BFFFFFFF000000_00 -FFFFFDBF C082080000000000_00 -FFFFF189 C0ACEE0000000000_00 -0FFFFFFF 41AFFFFFFE000000_00 -FFFE6FFE C0F9002000000000_00 -FC8672A0 C18BCC6B00000000_00 -07FFFFFF 419FFFFFFC000000_00 -00000107 4070700000000000_00 -FFFCCA70 C109AC8000000000_00 -03FFFFFF 418FFFFFF8000000_00 -002107FE 414083FF00000000_00 -FFFF48E7 C0E6E32000000000_00 -01FFFFFF 417FFFFFF0000000_00 -F7FDFFEE C1A0040024000000_00 -00000010 4030000000000000_00 -00FFFFFF 416FFFFFE0000000_00 -FFFF01FD C0EFC06000000000_00 -0000FAEF 40EF5DE000000000_00 -007FFFFF 415FFFFFC0000000_00 -00FC0001 416F800020000000_00 -000000F5 406EA00000000000_00 -003FFFFF 414FFFFF80000000_00 -FFE07FC0 C13F804000000000_00 -001AFFFB 413AFFFB00000000_00 -001FFFFF 413FFFFF00000000_00 -00101FFD 41301FFD00000000_00 -FF4613B2 C1673D89C0000000_00 -000FFFFF 412FFFFE00000000_00 -F00005FE C1AFFFF404000000_00 -00036402 410B201000000000_00 -0007FFFF 411FFFFC00000000_00 -0404FFFF 419013FFFC000000_00 -021C2358 4180E11AC0000000_00 -0003FFFF 410FFFF800000000_00 -FFFFFD02 C087F00000000000_00 -FFFF41C6 C0E7C74000000000_00 -0001FFFF 40FFFFF000000000_00 -00000007 401C000000000000_00 -27F174DE 41C3F8BA6F000000_00 -0000FFFF 40EFFFE000000000_00 -000083F5 40E07EA000000000_00 -FFFFFFFB C014000000000000_00 -00007FFF 40DFFFC000000000_00 -FE7FDFFE C178020020000000_00 -FFFFFFFD C008000000000000_00 -00003FFF 40CFFF8000000000_00 -DBBFFFFE C1C2200001000000_00 -00000404 4090100000000000_00 -00001FFF 40BFFF0000000000_00 -FFFFC018 C0CFF40000000000_00 -00002853 40C4298000000000_00 -00000FFF 40AFFE0000000000_00 -03FE007F 418FF003F8000000_00 -FFFFF124 C0ADB80000000000_00 -000007FF 409FFC0000000000_00 -FFFFEFBE C0B0420000000000_00 -FFFB9AD8 C11194A000000000_00 -000003FF 408FF80000000000_00 -DFFFFDFE C1C0000101000000_00 -FFFFFD95 C083580000000000_00 -000001FF 407FF00000000000_00 -FDFFFFFF C180000008000000_00 -FFFFFFD0 C048000000000000_00 -000000FF 406FE00000000000_00 -0037FFE0 414BFFF000000000_00 -010EC496 4170EC4960000000_00 -0000007F 405FC00000000000_00 -B8007FFF C1D1FFE000400000_00 -00000012 4032000000000000_00 -0000003F 404F800000000000_00 -02003FFC 418001FFE0000000_00 -FFFFFFEF C031000000000000_00 -0000001F 403F000000000000_00 -FF7FFF02 C160001FC0000000_00 -FFFFE2CE C0BD320000000000_00 -0000000F 402E000000000000_00 -0000A00D 40E401A000000000_00 -FFFFFE44 C07BC00000000000_00 -00000007 401C000000000000_00 -0003FFFA 410FFFD000000000_00 -000038E7 40CC738000000000_00 -00000003 4008000000000000_00 +1FEFFFEF_41BFEFFFEF000000_00 +FFFFC48E_C0CDB90000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00009E14_40E3C28000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +FFFFDE38_C0C0E40000000000_00 +00000002_4000000000000000_00 +FFDFFC02_C14001FF00000000_00 +FB794C79_C1921ACE1C000000_00 +00000004_4010000000000000_00 +F00FFFFE_C1AFE00004000000_00 +00000A95_40A52A0000000000_00 +00000008_4020000000000000_00 +FFFFF97F_C09A040000000000_00 +FFAE458D_C1546E9CC0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +29EB4561_41C4F5A2B0800000_00 +00000020_4040000000000000_00 +8001FFEE_C1DFFF8004800000_00 +FFFBDD08_C1108BE000000000_00 +00000040_4050000000000000_00 +FFF03FF9_C12F800E00000000_00 +FFCEDF36_C148906500000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000279_4083C80000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_C1D0000004400000_00 +00000007_401C000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +FFFFF590_C0A4E00000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_C1A000020A000000_00 +2FEA335F_41C7F519AF800000_00 +00000800_40A0000000000000_00 +FFC07FFF_C14FC00080000000_00 +177957FD_41B77957FD000000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +FFFFFAC9_C094DC0000000000_00 +00002000_40C0000000000000_00 +FFFF8004_C0DFFF0000000000_00 +FFFBE0DE_C1107C8800000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000000_0000000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_C15F7F8040000000_00 +FFFFD2F1_C0C6878000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0011B7E5_4131B7E500000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0013F7E6_4133F7E600000000_00 +00040000_4110000000000000_00 +FFFDC007_C101FFC800000000_00 +FD0ABD9A_C187AA1330000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00003CEE_40CE770000000000_00 +00100000_4130000000000000_00 +DFDFE000_C1C0101000000000_00 +FFFB1642_C113A6F800000000_00 +00200000_4140000000000000_00 +FC000078_C18FFFFC40000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +FFFFFE21_C07DF00000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_C160801020000000_00 +FFFF6393_C0E38DA000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +FFFFFDB4_C082600000000000_00 +02000000_4180000000000000_00 +8002FFFF_C1DFFF4000400000_00 +FFFFC8E2_C0CB8F0000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_C10F901000000000_00 +FFFFFF1B_C06CA00000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0001092B_40F092B000000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +00B4F3D1_41669E7A20000000_00 +20000000_41C0000000000000_00 +FEF801FF_C1707FE010000000_00 +00000005_4014000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_C1D0030000800000_00 +0001806B_40F806B000000000_00 +80000000_C1E0000000000000_00 +0000A07E_40E40FC000000000_00 +FFFFA59F_C0D6984000000000_00 +C0000000_C1D0000000000000_00 +E0007FDE_C1BFFF8022000000_00 +FFF8343E_C11F2F0800000000_00 +E0000000_C1C0000000000000_00 +0000FF7C_40EFEF8000000000_00 +FFFFFFF7_C022000000000000_00 +F0000000_C1B0000000000000_00 +BDFFFFFC_C1D0800001000000_00 +FFFFE3C1_C0BC3F0000000000_00 +F8000000_C1A0000000000000_00 +28003FFE_41C4001FFF000000_00 +00000000_0000000000000000_00 +FC000000_C190000000000000_00 +00EEFFFF_416DDFFFE0000000_00 +00003EB0_40CF580000000000_00 +FE000000_C180000000000000_00 +00000F7D_40AEFA0000000000_00 +FFFFFF0F_C06E200000000000_00 +FF000000_C170000000000000_00 +0000406D_40D01B4000000000_00 +0000001A_403A000000000000_00 +FF800000_C160000000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000000A_4024000000000000_00 +FFC00000_C150000000000000_00 +FFFF007C_C0EFF08000000000_00 +0000009B_4063600000000000_00 +FFE00000_C140000000000000_00 +00E00FFF_416C01FFE0000000_00 +00000006_4018000000000000_00 +FFF00000_C130000000000000_00 +00200FFC_414007FE00000000_00 +00000714_409C500000000000_00 +FFF80000_C120000000000000_00 +F800040E_C19FFFEFC8000000_00 +00000013_4033000000000000_00 +FFFC0000_C110000000000000_00 +F83BFFFF_C19F100004000000_00 +FFF3F584_C12814F800000000_00 +FFFE0000_C100000000000000_00 +F6FFFBFF_C1A2000802000000_00 +FFFFFFF0_C030000000000000_00 +FFFF0000_C0F0000000000000_00 +80003FFD_C1DFFFF000C00000_00 +FFFFFFAD_C054C00000000000_00 +FFFF8000_C0E0000000000000_00 +004001FD_4150007F40000000_00 +000D734E_412AE69C00000000_00 +FFFFC000_C0D0000000000000_00 +006003FE_415800FF80000000_00 +FF9DBAA8_C158915600000000_00 +FFFFE000_C0C0000000000000_00 +000403EE_41100FB800000000_00 +00734668_415CD19A00000000_00 +FFFFF000_C0B0000000000000_00 +01200002_4172000020000000_00 +FF8874A5_C15DE2D6C0000000_00 +FFFFF800_C0A0000000000000_00 +00060001_4118000400000000_00 +FFFFFFF8_C020000000000000_00 +FFFFFC00_C090000000000000_00 +001FFEDD_413FFEDD00000000_00 +FFFC56DF_C10D490800000000_00 +FFFFFE00_C080000000000000_00 +EFFFEFFD_C1B0001003000000_00 +FECF5EC6_C1730A13A0000000_00 +FFFFFF00_C070000000000000_00 +1FF00002_41BFF00002000000_00 +F6DB786B_C1A2490F2A000000_00 +FFFFFF80_C060000000000000_00 +F0000FBE_C1AFFFE084000000_00 +00000009_4022000000000000_00 +FFFFFFC0_C050000000000000_00 +0010801F_4130801F00000000_00 +0001F238_40FF238000000000_00 +FFFFFFE0_C040000000000000_00 +F8000047_C19FFFFEE4000000_00 +0002133C_410099E000000000_00 +FFFFFFF0_C030000000000000_00 +003C001F_414E000F80000000_00 +000001F1_407F100000000000_00 +FFFFFFF8_C020000000000000_00 +FFDFBFFF_C140200080000000_00 +FF5E507F_C16435F020000000_00 +FFFFFFFC_C010000000000000_00 +037FFFDE_418BFFFEF0000000_00 +FFFD7C6F_C1041C8800000000_00 +FFFFFFFE_C000000000000000_00 +000000FD_406FA00000000000_00 +FFFFF42A_C0A7AC0000000000_00 +FFFFFFFF_BFF0000000000000_00 +021FFF7D_4180FFFBE8000000_00 +0000000A_4024000000000000_00 +FFFFFFFD_C008000000000000_00 +4010FFFF_41D0043FFFC00000_00 +FFFFFFD3_C046800000000000_00 +FFFFFFFB_C014000000000000_00 +FFFF800B_C0DFFD4000000000_00 +000000B8_4067000000000000_00 +FFFFFFF7_C022000000000000_00 +FF800803_C15FFDFF40000000_00 +FFFFFFFE_C000000000000000_00 +FFFFFFEF_C031000000000000_00 +00803FFB_416007FF60000000_00 +00000308_4088400000000000_00 +FFFFFFDF_C040800000000000_00 +2107FFFE_41C083FFFF000000_00 +FFE15D4F_C13EA2B100000000_00 +FFFFFFBF_C050400000000000_00 +400087FD_41D00021FF400000_00 +0000000F_402E000000000000_00 +FFFFFF7F_C060200000000000_00 +FDFC007E_C1801FFC10000000_00 +00000006_4018000000000000_00 +FFFFFEFF_C070100000000000_00 +FFF80100_C11FFC0000000000_00 +FFFFFE99_C076700000000000_00 +FFFFFDFF_C080080000000000_00 +03000002_4188000010000000_00 +FFF716EA_C121D22C00000000_00 +FFFFFBFF_C090040000000000_00 +C7FDFFFF_C1CC010000800000_00 +FFFFE327_C0BCD90000000000_00 +FFFFF7FF_C0A0020000000000_00 +0103DFFE_41703DFFE0000000_00 +07661FD8_419D987F60000000_00 +FFFFEFFF_C0B0010000000000_00 +83FFFFFE_C1DF000000800000_00 +FCD956DB_C189354928000000_00 +FFFFDFFF_C0C0008000000000_00 +FF2001FD_C16BFFC060000000_00 +E4D35BBF_C1BB2CA441000000_00 +FFFFBFFF_C0D0004000000000_00 +DFEFEFFE_C1C0080801000000_00 +05DA4300_4197690C00000000_00 +FFFF7FFF_C0E0002000000000_00 +40001040_41D0000410000000_00 +812EDF40_C1DFB44830000000_00 +FFFEFFFF_C0F0001000000000_00 +FFFFC007_C0CFFC8000000000_00 +00B6FCC9_4166DF9920000000_00 +FFFDFFFF_C100000800000000_00 +000007FE_409FF80000000000_00 +FC3DE950_C18E10B580000000_00 +FFFBFFFF_C110000400000000_00 +7FFFFE03_41DFFFFF80C00000_00 +FEB02B59_C174FD4A70000000_00 +FFF7FFFF_C120000200000000_00 +10FF7FFF_41B0FF7FFF000000_00 +00008D5E_40E1ABC000000000_00 +FFEFFFFF_C130000100000000_00 +FFFF007E_C0EFF04000000000_00 +001C2108_413C210800000000_00 +FFDFFFFF_C140000080000000_00 +00FFC001_416FF80020000000_00 +F01C6B36_C1AFC72994000000_00 +FFBFFFFF_C150000040000000_00 +FFFF7FFF_C0E0002000000000_00 +FFFFD055_C0C7D58000000000_00 +FF7FFFFF_C160000020000000_00 +027BFFFE_4183DFFFF0000000_00 +FF3090D0_C169EDE600000000_00 +FEFFFFFF_C170000010000000_00 +00082040_4120408000000000_00 +0000006E_405B800000000000_00 +FDFFFFFF_C180000008000000_00 +FDFFFF87_C1800003C8000000_00 +04C3764D_41930DD934000000_00 +FBFFFFFF_C190000004000000_00 +0006007E_411801F800000000_00 +000001EF_407EF00000000000_00 +F7FFFFFF_C1A0000002000000_00 +FFBF7FFE_C150200080000000_00 +FF1C4E5A_C16C7634C0000000_00 +EFFFFFFF_C1B0000001000000_00 +FFF97FFD_C11A000C00000000_00 +000001D1_407D100000000000_00 +DFFFFFFF_C1C0000000800000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00136721_4133672100000000_00 +BFFFFFFF_C1D0000000400000_00 +00004BFF_40D2FFC000000000_00 +00000544_4095100000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +FFF8BD5E_C11D0A8800000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_C1501FFF40000000_00 +FFFE45D2_C0FBA2E000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_C082080000000000_00 +FFFFF189_C0ACEE0000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_C0F9002000000000_00 +FC8672A0_C18BCC6B00000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +FFFCCA70_C109AC8000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +FFFF48E7_C0E6E32000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_C1A0040024000000_00 +00000010_4030000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_C0EFC06000000000_00 +0000FAEF_40EF5DE000000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000000F5_406EA00000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_C13F804000000000_00 +001AFFFB_413AFFFB00000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +FF4613B2_C1673D89C0000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_C1AFFFF404000000_00 +00036402_410B201000000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_C087F00000000000_00 +FFFF41C6_C0E7C74000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +FFFFFFFB_C014000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_C178020020000000_00 +FFFFFFFD_C008000000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_C1C2200001000000_00 +00000404_4090100000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_C0CFF40000000000_00 +00002853_40C4298000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +FFFFF124_C0ADB80000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_C0B0420000000000_00 +FFFB9AD8_C11194A000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_C1C0000101000000_00 +FFFFFD95_C083580000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_C180000008000000_00 +FFFFFFD0_C048000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +010EC496_4170EC4960000000_00 +0000007F_405FC00000000000_00 +B8007FFF_C1D1FFE000400000_00 +00000012_4032000000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +FFFFFFEF_C031000000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_C160001FC0000000_00 +FFFFE2CE_C0BD320000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +FFFFFE44_C07BC00000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +000038E7_40CC738000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_rne.tv b/wally-pipelined/testbench/fp/i32_f64_rne.tv index 7f04b63fd..3e4622082 100644 --- a/wally-pipelined/testbench/fp/i32_f64_rne.tv +++ b/wally-pipelined/testbench/fp/i32_f64_rne.tv @@ -1,372 +1,372 @@ -1FEFFFEF 41BFEFFFEF000000_00 -FFFFC48E C0CDB90000000000_00 -00000000 0000000000000000_00 -007FFFCD 415FFFF340000000_00 -00009E14 40E3C28000000000_00 -00000001 3FF0000000000000_00 -001FFFFB 413FFFFB00000000_00 -FFFFDE38 C0C0E40000000000_00 -00000002 4000000000000000_00 -FFDFFC02 C14001FF00000000_00 -FB794C79 C1921ACE1C000000_00 -00000004 4010000000000000_00 -F00FFFFE C1AFE00004000000_00 -00000A95 40A52A0000000000_00 -00000008 4020000000000000_00 -FFFFF97F C09A040000000000_00 -FFAE458D C1546E9CC0000000_00 -00000010 4030000000000000_00 -0101001E 41701001E0000000_00 -29EB4561 41C4F5A2B0800000_00 -00000020 4040000000000000_00 -8001FFEE C1DFFF8004800000_00 -FFFBDD08 C1108BE000000000_00 -00000040 4050000000000000_00 -FFF03FF9 C12F800E00000000_00 -FFCEDF36 C148906500000000_00 -00000080 4060000000000000_00 -0000F01F 40EE03E000000000_00 -00000279 4083C80000000000_00 -00000100 4070000000000000_00 -BFFFFFEF C1D0000004400000_00 -00000007 401C000000000000_00 -00000200 4080000000000000_00 -010BFFFD 4170BFFFD0000000_00 -FFFFF590 C0A4E00000000000_00 -00000400 4090000000000000_00 -F7FFFEFB C1A000020A000000_00 -2FEA335F 41C7F519AF800000_00 -00000800 40A0000000000000_00 -FFC07FFF C14FC00080000000_00 -177957FD 41B77957FD000000_00 -00001000 40B0000000000000_00 -01FBFFEE 417FBFFEE0000000_00 -FFFFFAC9 C094DC0000000000_00 -00002000 40C0000000000000_00 -FFFF8004 C0DFFF0000000000_00 -FFFBE0DE C1107C8800000000_00 -00004000 40D0000000000000_00 -3F00001E 41CF80000F000000_00 -00000000 0000000000000000_00 -00008000 40E0000000000000_00 -FF8201FF C15F7F8040000000_00 -FFFFD2F1 C0C6878000000000_00 -00010000 40F0000000000000_00 -0000047E 4091F80000000000_00 -0011B7E5 4131B7E500000000_00 -00020000 4100000000000000_00 -02200200 4181001000000000_00 -0013F7E6 4133F7E600000000_00 -00040000 4110000000000000_00 -FFFDC007 C101FFC800000000_00 -FD0ABD9A C187AA1330000000_00 -00080000 4120000000000000_00 -0000607F 40D81FC000000000_00 -00003CEE 40CE770000000000_00 -00100000 4130000000000000_00 -DFDFE000 C1C0101000000000_00 -FFFB1642 C113A6F800000000_00 -00200000 4140000000000000_00 -FC000078 C18FFFFC40000000_00 -5F70EEC1 41D7DC3BB0400000_00 -00400000 4150000000000000_00 -00100082 4130008200000000_00 -FFFFFE21 C07DF00000000000_00 -00800000 4160000000000000_00 -FF7BFF7F C160801020000000_00 -FFFF6393 C0E38DA000000000_00 -01000000 4170000000000000_00 -07EFFEFD 419FBFFBF4000000_00 -FFFFFDB4 C082600000000000_00 -02000000 4180000000000000_00 -8002FFFF C1DFFF4000400000_00 -FFFFC8E2 C0CB8F0000000000_00 -04000000 4190000000000000_00 -FFFC0DFE C10F901000000000_00 -FFFFFF1B C06CA00000000000_00 -08000000 41A0000000000000_00 -03FFFDBF 418FFFEDF8000000_00 -0001092B 40F092B000000000_00 -10000000 41B0000000000000_00 -007FBFFD 415FEFFF40000000_00 -00B4F3D1 41669E7A20000000_00 -20000000 41C0000000000000_00 -FEF801FF C1707FE010000000_00 -00000005 4014000000000000_00 -40000000 41D0000000000000_00 -BFF3FFFE C1D0030000800000_00 -0001806B 40F806B000000000_00 -80000000 C1E0000000000000_00 -0000A07E 40E40FC000000000_00 -FFFFA59F C0D6984000000000_00 -C0000000 C1D0000000000000_00 -E0007FDE C1BFFF8022000000_00 -FFF8343E C11F2F0800000000_00 -E0000000 C1C0000000000000_00 -0000FF7C 40EFEF8000000000_00 -FFFFFFF7 C022000000000000_00 -F0000000 C1B0000000000000_00 -BDFFFFFC C1D0800001000000_00 -FFFFE3C1 C0BC3F0000000000_00 -F8000000 C1A0000000000000_00 -28003FFE 41C4001FFF000000_00 -00000000 0000000000000000_00 -FC000000 C190000000000000_00 -00EEFFFF 416DDFFFE0000000_00 -00003EB0 40CF580000000000_00 -FE000000 C180000000000000_00 -00000F7D 40AEFA0000000000_00 -FFFFFF0F C06E200000000000_00 -FF000000 C170000000000000_00 -0000406D 40D01B4000000000_00 -0000001A 403A000000000000_00 -FF800000 C160000000000000_00 -203FFFFD 41C01FFFFE800000_00 -0000000A 4024000000000000_00 -FFC00000 C150000000000000_00 -FFFF007C C0EFF08000000000_00 -0000009B 4063600000000000_00 -FFE00000 C140000000000000_00 -00E00FFF 416C01FFE0000000_00 -00000006 4018000000000000_00 -FFF00000 C130000000000000_00 -00200FFC 414007FE00000000_00 -00000714 409C500000000000_00 -FFF80000 C120000000000000_00 -F800040E C19FFFEFC8000000_00 -00000013 4033000000000000_00 -FFFC0000 C110000000000000_00 -F83BFFFF C19F100004000000_00 -FFF3F584 C12814F800000000_00 -FFFE0000 C100000000000000_00 -F6FFFBFF C1A2000802000000_00 -FFFFFFF0 C030000000000000_00 -FFFF0000 C0F0000000000000_00 -80003FFD C1DFFFF000C00000_00 -FFFFFFAD C054C00000000000_00 -FFFF8000 C0E0000000000000_00 -004001FD 4150007F40000000_00 -000D734E 412AE69C00000000_00 -FFFFC000 C0D0000000000000_00 -006003FE 415800FF80000000_00 -FF9DBAA8 C158915600000000_00 -FFFFE000 C0C0000000000000_00 -000403EE 41100FB800000000_00 -00734668 415CD19A00000000_00 -FFFFF000 C0B0000000000000_00 -01200002 4172000020000000_00 -FF8874A5 C15DE2D6C0000000_00 -FFFFF800 C0A0000000000000_00 -00060001 4118000400000000_00 -FFFFFFF8 C020000000000000_00 -FFFFFC00 C090000000000000_00 -001FFEDD 413FFEDD00000000_00 -FFFC56DF C10D490800000000_00 -FFFFFE00 C080000000000000_00 -EFFFEFFD C1B0001003000000_00 -FECF5EC6 C1730A13A0000000_00 -FFFFFF00 C070000000000000_00 -1FF00002 41BFF00002000000_00 -F6DB786B C1A2490F2A000000_00 -FFFFFF80 C060000000000000_00 -F0000FBE C1AFFFE084000000_00 -00000009 4022000000000000_00 -FFFFFFC0 C050000000000000_00 -0010801F 4130801F00000000_00 -0001F238 40FF238000000000_00 -FFFFFFE0 C040000000000000_00 -F8000047 C19FFFFEE4000000_00 -0002133C 410099E000000000_00 -FFFFFFF0 C030000000000000_00 -003C001F 414E000F80000000_00 -000001F1 407F100000000000_00 -FFFFFFF8 C020000000000000_00 -FFDFBFFF C140200080000000_00 -FF5E507F C16435F020000000_00 -FFFFFFFC C010000000000000_00 -037FFFDE 418BFFFEF0000000_00 -FFFD7C6F C1041C8800000000_00 -FFFFFFFE C000000000000000_00 -000000FD 406FA00000000000_00 -FFFFF42A C0A7AC0000000000_00 -FFFFFFFF BFF0000000000000_00 -021FFF7D 4180FFFBE8000000_00 -0000000A 4024000000000000_00 -FFFFFFFD C008000000000000_00 -4010FFFF 41D0043FFFC00000_00 -FFFFFFD3 C046800000000000_00 -FFFFFFFB C014000000000000_00 -FFFF800B C0DFFD4000000000_00 -000000B8 4067000000000000_00 -FFFFFFF7 C022000000000000_00 -FF800803 C15FFDFF40000000_00 -FFFFFFFE C000000000000000_00 -FFFFFFEF C031000000000000_00 -00803FFB 416007FF60000000_00 -00000308 4088400000000000_00 -FFFFFFDF C040800000000000_00 -2107FFFE 41C083FFFF000000_00 -FFE15D4F C13EA2B100000000_00 -FFFFFFBF C050400000000000_00 -400087FD 41D00021FF400000_00 -0000000F 402E000000000000_00 -FFFFFF7F C060200000000000_00 -FDFC007E C1801FFC10000000_00 -00000006 4018000000000000_00 -FFFFFEFF C070100000000000_00 -FFF80100 C11FFC0000000000_00 -FFFFFE99 C076700000000000_00 -FFFFFDFF C080080000000000_00 -03000002 4188000010000000_00 -FFF716EA C121D22C00000000_00 -FFFFFBFF C090040000000000_00 -C7FDFFFF C1CC010000800000_00 -FFFFE327 C0BCD90000000000_00 -FFFFF7FF C0A0020000000000_00 -0103DFFE 41703DFFE0000000_00 -07661FD8 419D987F60000000_00 -FFFFEFFF C0B0010000000000_00 -83FFFFFE C1DF000000800000_00 -FCD956DB C189354928000000_00 -FFFFDFFF C0C0008000000000_00 -FF2001FD C16BFFC060000000_00 -E4D35BBF C1BB2CA441000000_00 -FFFFBFFF C0D0004000000000_00 -DFEFEFFE C1C0080801000000_00 -05DA4300 4197690C00000000_00 -FFFF7FFF C0E0002000000000_00 -40001040 41D0000410000000_00 -812EDF40 C1DFB44830000000_00 -FFFEFFFF C0F0001000000000_00 -FFFFC007 C0CFFC8000000000_00 -00B6FCC9 4166DF9920000000_00 -FFFDFFFF C100000800000000_00 -000007FE 409FF80000000000_00 -FC3DE950 C18E10B580000000_00 -FFFBFFFF C110000400000000_00 -7FFFFE03 41DFFFFF80C00000_00 -FEB02B59 C174FD4A70000000_00 -FFF7FFFF C120000200000000_00 -10FF7FFF 41B0FF7FFF000000_00 -00008D5E 40E1ABC000000000_00 -FFEFFFFF C130000100000000_00 -FFFF007E C0EFF04000000000_00 -001C2108 413C210800000000_00 -FFDFFFFF C140000080000000_00 -00FFC001 416FF80020000000_00 -F01C6B36 C1AFC72994000000_00 -FFBFFFFF C150000040000000_00 -FFFF7FFF C0E0002000000000_00 -FFFFD055 C0C7D58000000000_00 -FF7FFFFF C160000020000000_00 -027BFFFE 4183DFFFF0000000_00 -FF3090D0 C169EDE600000000_00 -FEFFFFFF C170000010000000_00 -00082040 4120408000000000_00 -0000006E 405B800000000000_00 -FDFFFFFF C180000008000000_00 -FDFFFF87 C1800003C8000000_00 -04C3764D 41930DD934000000_00 -FBFFFFFF C190000004000000_00 -0006007E 411801F800000000_00 -000001EF 407EF00000000000_00 -F7FFFFFF C1A0000002000000_00 -FFBF7FFE C150200080000000_00 -FF1C4E5A C16C7634C0000000_00 -EFFFFFFF C1B0000001000000_00 -FFF97FFD C11A000C00000000_00 -000001D1 407D100000000000_00 -DFFFFFFF C1C0000000800000_00 -2FFFFFFE 41C7FFFFFF000000_00 -00136721 4133672100000000_00 -BFFFFFFF C1D0000000400000_00 -00004BFF 40D2FFC000000000_00 -00000544 4095100000000000_00 -7FFFFFFF 41DFFFFFFFC00000_00 -007FDFFB 415FF7FEC0000000_00 -FFF8BD5E C11D0A8800000000_00 -3FFFFFFF 41CFFFFFFF800000_00 -FFBF8003 C1501FFF40000000_00 -FFFE45D2 C0FBA2E000000000_00 -1FFFFFFF 41BFFFFFFF000000_00 -FFFFFDBF C082080000000000_00 -FFFFF189 C0ACEE0000000000_00 -0FFFFFFF 41AFFFFFFE000000_00 -FFFE6FFE C0F9002000000000_00 -FC8672A0 C18BCC6B00000000_00 -07FFFFFF 419FFFFFFC000000_00 -00000107 4070700000000000_00 -FFFCCA70 C109AC8000000000_00 -03FFFFFF 418FFFFFF8000000_00 -002107FE 414083FF00000000_00 -FFFF48E7 C0E6E32000000000_00 -01FFFFFF 417FFFFFF0000000_00 -F7FDFFEE C1A0040024000000_00 -00000010 4030000000000000_00 -00FFFFFF 416FFFFFE0000000_00 -FFFF01FD C0EFC06000000000_00 -0000FAEF 40EF5DE000000000_00 -007FFFFF 415FFFFFC0000000_00 -00FC0001 416F800020000000_00 -000000F5 406EA00000000000_00 -003FFFFF 414FFFFF80000000_00 -FFE07FC0 C13F804000000000_00 -001AFFFB 413AFFFB00000000_00 -001FFFFF 413FFFFF00000000_00 -00101FFD 41301FFD00000000_00 -FF4613B2 C1673D89C0000000_00 -000FFFFF 412FFFFE00000000_00 -F00005FE C1AFFFF404000000_00 -00036402 410B201000000000_00 -0007FFFF 411FFFFC00000000_00 -0404FFFF 419013FFFC000000_00 -021C2358 4180E11AC0000000_00 -0003FFFF 410FFFF800000000_00 -FFFFFD02 C087F00000000000_00 -FFFF41C6 C0E7C74000000000_00 -0001FFFF 40FFFFF000000000_00 -00000007 401C000000000000_00 -27F174DE 41C3F8BA6F000000_00 -0000FFFF 40EFFFE000000000_00 -000083F5 40E07EA000000000_00 -FFFFFFFB C014000000000000_00 -00007FFF 40DFFFC000000000_00 -FE7FDFFE C178020020000000_00 -FFFFFFFD C008000000000000_00 -00003FFF 40CFFF8000000000_00 -DBBFFFFE C1C2200001000000_00 -00000404 4090100000000000_00 -00001FFF 40BFFF0000000000_00 -FFFFC018 C0CFF40000000000_00 -00002853 40C4298000000000_00 -00000FFF 40AFFE0000000000_00 -03FE007F 418FF003F8000000_00 -FFFFF124 C0ADB80000000000_00 -000007FF 409FFC0000000000_00 -FFFFEFBE C0B0420000000000_00 -FFFB9AD8 C11194A000000000_00 -000003FF 408FF80000000000_00 -DFFFFDFE C1C0000101000000_00 -FFFFFD95 C083580000000000_00 -000001FF 407FF00000000000_00 -FDFFFFFF C180000008000000_00 -FFFFFFD0 C048000000000000_00 -000000FF 406FE00000000000_00 -0037FFE0 414BFFF000000000_00 -010EC496 4170EC4960000000_00 -0000007F 405FC00000000000_00 -B8007FFF C1D1FFE000400000_00 -00000012 4032000000000000_00 -0000003F 404F800000000000_00 -02003FFC 418001FFE0000000_00 -FFFFFFEF C031000000000000_00 -0000001F 403F000000000000_00 -FF7FFF02 C160001FC0000000_00 -FFFFE2CE C0BD320000000000_00 -0000000F 402E000000000000_00 -0000A00D 40E401A000000000_00 -FFFFFE44 C07BC00000000000_00 -00000007 401C000000000000_00 -0003FFFA 410FFFD000000000_00 -000038E7 40CC738000000000_00 -00000003 4008000000000000_00 +1FEFFFEF_41BFEFFFEF000000_00 +FFFFC48E_C0CDB90000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00009E14_40E3C28000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +FFFFDE38_C0C0E40000000000_00 +00000002_4000000000000000_00 +FFDFFC02_C14001FF00000000_00 +FB794C79_C1921ACE1C000000_00 +00000004_4010000000000000_00 +F00FFFFE_C1AFE00004000000_00 +00000A95_40A52A0000000000_00 +00000008_4020000000000000_00 +FFFFF97F_C09A040000000000_00 +FFAE458D_C1546E9CC0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +29EB4561_41C4F5A2B0800000_00 +00000020_4040000000000000_00 +8001FFEE_C1DFFF8004800000_00 +FFFBDD08_C1108BE000000000_00 +00000040_4050000000000000_00 +FFF03FF9_C12F800E00000000_00 +FFCEDF36_C148906500000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000279_4083C80000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_C1D0000004400000_00 +00000007_401C000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +FFFFF590_C0A4E00000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_C1A000020A000000_00 +2FEA335F_41C7F519AF800000_00 +00000800_40A0000000000000_00 +FFC07FFF_C14FC00080000000_00 +177957FD_41B77957FD000000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +FFFFFAC9_C094DC0000000000_00 +00002000_40C0000000000000_00 +FFFF8004_C0DFFF0000000000_00 +FFFBE0DE_C1107C8800000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000000_0000000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_C15F7F8040000000_00 +FFFFD2F1_C0C6878000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0011B7E5_4131B7E500000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0013F7E6_4133F7E600000000_00 +00040000_4110000000000000_00 +FFFDC007_C101FFC800000000_00 +FD0ABD9A_C187AA1330000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00003CEE_40CE770000000000_00 +00100000_4130000000000000_00 +DFDFE000_C1C0101000000000_00 +FFFB1642_C113A6F800000000_00 +00200000_4140000000000000_00 +FC000078_C18FFFFC40000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +FFFFFE21_C07DF00000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_C160801020000000_00 +FFFF6393_C0E38DA000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +FFFFFDB4_C082600000000000_00 +02000000_4180000000000000_00 +8002FFFF_C1DFFF4000400000_00 +FFFFC8E2_C0CB8F0000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_C10F901000000000_00 +FFFFFF1B_C06CA00000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0001092B_40F092B000000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +00B4F3D1_41669E7A20000000_00 +20000000_41C0000000000000_00 +FEF801FF_C1707FE010000000_00 +00000005_4014000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_C1D0030000800000_00 +0001806B_40F806B000000000_00 +80000000_C1E0000000000000_00 +0000A07E_40E40FC000000000_00 +FFFFA59F_C0D6984000000000_00 +C0000000_C1D0000000000000_00 +E0007FDE_C1BFFF8022000000_00 +FFF8343E_C11F2F0800000000_00 +E0000000_C1C0000000000000_00 +0000FF7C_40EFEF8000000000_00 +FFFFFFF7_C022000000000000_00 +F0000000_C1B0000000000000_00 +BDFFFFFC_C1D0800001000000_00 +FFFFE3C1_C0BC3F0000000000_00 +F8000000_C1A0000000000000_00 +28003FFE_41C4001FFF000000_00 +00000000_0000000000000000_00 +FC000000_C190000000000000_00 +00EEFFFF_416DDFFFE0000000_00 +00003EB0_40CF580000000000_00 +FE000000_C180000000000000_00 +00000F7D_40AEFA0000000000_00 +FFFFFF0F_C06E200000000000_00 +FF000000_C170000000000000_00 +0000406D_40D01B4000000000_00 +0000001A_403A000000000000_00 +FF800000_C160000000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000000A_4024000000000000_00 +FFC00000_C150000000000000_00 +FFFF007C_C0EFF08000000000_00 +0000009B_4063600000000000_00 +FFE00000_C140000000000000_00 +00E00FFF_416C01FFE0000000_00 +00000006_4018000000000000_00 +FFF00000_C130000000000000_00 +00200FFC_414007FE00000000_00 +00000714_409C500000000000_00 +FFF80000_C120000000000000_00 +F800040E_C19FFFEFC8000000_00 +00000013_4033000000000000_00 +FFFC0000_C110000000000000_00 +F83BFFFF_C19F100004000000_00 +FFF3F584_C12814F800000000_00 +FFFE0000_C100000000000000_00 +F6FFFBFF_C1A2000802000000_00 +FFFFFFF0_C030000000000000_00 +FFFF0000_C0F0000000000000_00 +80003FFD_C1DFFFF000C00000_00 +FFFFFFAD_C054C00000000000_00 +FFFF8000_C0E0000000000000_00 +004001FD_4150007F40000000_00 +000D734E_412AE69C00000000_00 +FFFFC000_C0D0000000000000_00 +006003FE_415800FF80000000_00 +FF9DBAA8_C158915600000000_00 +FFFFE000_C0C0000000000000_00 +000403EE_41100FB800000000_00 +00734668_415CD19A00000000_00 +FFFFF000_C0B0000000000000_00 +01200002_4172000020000000_00 +FF8874A5_C15DE2D6C0000000_00 +FFFFF800_C0A0000000000000_00 +00060001_4118000400000000_00 +FFFFFFF8_C020000000000000_00 +FFFFFC00_C090000000000000_00 +001FFEDD_413FFEDD00000000_00 +FFFC56DF_C10D490800000000_00 +FFFFFE00_C080000000000000_00 +EFFFEFFD_C1B0001003000000_00 +FECF5EC6_C1730A13A0000000_00 +FFFFFF00_C070000000000000_00 +1FF00002_41BFF00002000000_00 +F6DB786B_C1A2490F2A000000_00 +FFFFFF80_C060000000000000_00 +F0000FBE_C1AFFFE084000000_00 +00000009_4022000000000000_00 +FFFFFFC0_C050000000000000_00 +0010801F_4130801F00000000_00 +0001F238_40FF238000000000_00 +FFFFFFE0_C040000000000000_00 +F8000047_C19FFFFEE4000000_00 +0002133C_410099E000000000_00 +FFFFFFF0_C030000000000000_00 +003C001F_414E000F80000000_00 +000001F1_407F100000000000_00 +FFFFFFF8_C020000000000000_00 +FFDFBFFF_C140200080000000_00 +FF5E507F_C16435F020000000_00 +FFFFFFFC_C010000000000000_00 +037FFFDE_418BFFFEF0000000_00 +FFFD7C6F_C1041C8800000000_00 +FFFFFFFE_C000000000000000_00 +000000FD_406FA00000000000_00 +FFFFF42A_C0A7AC0000000000_00 +FFFFFFFF_BFF0000000000000_00 +021FFF7D_4180FFFBE8000000_00 +0000000A_4024000000000000_00 +FFFFFFFD_C008000000000000_00 +4010FFFF_41D0043FFFC00000_00 +FFFFFFD3_C046800000000000_00 +FFFFFFFB_C014000000000000_00 +FFFF800B_C0DFFD4000000000_00 +000000B8_4067000000000000_00 +FFFFFFF7_C022000000000000_00 +FF800803_C15FFDFF40000000_00 +FFFFFFFE_C000000000000000_00 +FFFFFFEF_C031000000000000_00 +00803FFB_416007FF60000000_00 +00000308_4088400000000000_00 +FFFFFFDF_C040800000000000_00 +2107FFFE_41C083FFFF000000_00 +FFE15D4F_C13EA2B100000000_00 +FFFFFFBF_C050400000000000_00 +400087FD_41D00021FF400000_00 +0000000F_402E000000000000_00 +FFFFFF7F_C060200000000000_00 +FDFC007E_C1801FFC10000000_00 +00000006_4018000000000000_00 +FFFFFEFF_C070100000000000_00 +FFF80100_C11FFC0000000000_00 +FFFFFE99_C076700000000000_00 +FFFFFDFF_C080080000000000_00 +03000002_4188000010000000_00 +FFF716EA_C121D22C00000000_00 +FFFFFBFF_C090040000000000_00 +C7FDFFFF_C1CC010000800000_00 +FFFFE327_C0BCD90000000000_00 +FFFFF7FF_C0A0020000000000_00 +0103DFFE_41703DFFE0000000_00 +07661FD8_419D987F60000000_00 +FFFFEFFF_C0B0010000000000_00 +83FFFFFE_C1DF000000800000_00 +FCD956DB_C189354928000000_00 +FFFFDFFF_C0C0008000000000_00 +FF2001FD_C16BFFC060000000_00 +E4D35BBF_C1BB2CA441000000_00 +FFFFBFFF_C0D0004000000000_00 +DFEFEFFE_C1C0080801000000_00 +05DA4300_4197690C00000000_00 +FFFF7FFF_C0E0002000000000_00 +40001040_41D0000410000000_00 +812EDF40_C1DFB44830000000_00 +FFFEFFFF_C0F0001000000000_00 +FFFFC007_C0CFFC8000000000_00 +00B6FCC9_4166DF9920000000_00 +FFFDFFFF_C100000800000000_00 +000007FE_409FF80000000000_00 +FC3DE950_C18E10B580000000_00 +FFFBFFFF_C110000400000000_00 +7FFFFE03_41DFFFFF80C00000_00 +FEB02B59_C174FD4A70000000_00 +FFF7FFFF_C120000200000000_00 +10FF7FFF_41B0FF7FFF000000_00 +00008D5E_40E1ABC000000000_00 +FFEFFFFF_C130000100000000_00 +FFFF007E_C0EFF04000000000_00 +001C2108_413C210800000000_00 +FFDFFFFF_C140000080000000_00 +00FFC001_416FF80020000000_00 +F01C6B36_C1AFC72994000000_00 +FFBFFFFF_C150000040000000_00 +FFFF7FFF_C0E0002000000000_00 +FFFFD055_C0C7D58000000000_00 +FF7FFFFF_C160000020000000_00 +027BFFFE_4183DFFFF0000000_00 +FF3090D0_C169EDE600000000_00 +FEFFFFFF_C170000010000000_00 +00082040_4120408000000000_00 +0000006E_405B800000000000_00 +FDFFFFFF_C180000008000000_00 +FDFFFF87_C1800003C8000000_00 +04C3764D_41930DD934000000_00 +FBFFFFFF_C190000004000000_00 +0006007E_411801F800000000_00 +000001EF_407EF00000000000_00 +F7FFFFFF_C1A0000002000000_00 +FFBF7FFE_C150200080000000_00 +FF1C4E5A_C16C7634C0000000_00 +EFFFFFFF_C1B0000001000000_00 +FFF97FFD_C11A000C00000000_00 +000001D1_407D100000000000_00 +DFFFFFFF_C1C0000000800000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00136721_4133672100000000_00 +BFFFFFFF_C1D0000000400000_00 +00004BFF_40D2FFC000000000_00 +00000544_4095100000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +FFF8BD5E_C11D0A8800000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_C1501FFF40000000_00 +FFFE45D2_C0FBA2E000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_C082080000000000_00 +FFFFF189_C0ACEE0000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_C0F9002000000000_00 +FC8672A0_C18BCC6B00000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +FFFCCA70_C109AC8000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +FFFF48E7_C0E6E32000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_C1A0040024000000_00 +00000010_4030000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_C0EFC06000000000_00 +0000FAEF_40EF5DE000000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000000F5_406EA00000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_C13F804000000000_00 +001AFFFB_413AFFFB00000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +FF4613B2_C1673D89C0000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_C1AFFFF404000000_00 +00036402_410B201000000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_C087F00000000000_00 +FFFF41C6_C0E7C74000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +FFFFFFFB_C014000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_C178020020000000_00 +FFFFFFFD_C008000000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_C1C2200001000000_00 +00000404_4090100000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_C0CFF40000000000_00 +00002853_40C4298000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +FFFFF124_C0ADB80000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_C0B0420000000000_00 +FFFB9AD8_C11194A000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_C1C0000101000000_00 +FFFFFD95_C083580000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_C180000008000000_00 +FFFFFFD0_C048000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +010EC496_4170EC4960000000_00 +0000007F_405FC00000000000_00 +B8007FFF_C1D1FFE000400000_00 +00000012_4032000000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +FFFFFFEF_C031000000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_C160001FC0000000_00 +FFFFE2CE_C0BD320000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +FFFFFE44_C07BC00000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +000038E7_40CC738000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_ru.tv b/wally-pipelined/testbench/fp/i32_f64_ru.tv index 7f04b63fd..3e4622082 100644 --- a/wally-pipelined/testbench/fp/i32_f64_ru.tv +++ b/wally-pipelined/testbench/fp/i32_f64_ru.tv @@ -1,372 +1,372 @@ -1FEFFFEF 41BFEFFFEF000000_00 -FFFFC48E C0CDB90000000000_00 -00000000 0000000000000000_00 -007FFFCD 415FFFF340000000_00 -00009E14 40E3C28000000000_00 -00000001 3FF0000000000000_00 -001FFFFB 413FFFFB00000000_00 -FFFFDE38 C0C0E40000000000_00 -00000002 4000000000000000_00 -FFDFFC02 C14001FF00000000_00 -FB794C79 C1921ACE1C000000_00 -00000004 4010000000000000_00 -F00FFFFE C1AFE00004000000_00 -00000A95 40A52A0000000000_00 -00000008 4020000000000000_00 -FFFFF97F C09A040000000000_00 -FFAE458D C1546E9CC0000000_00 -00000010 4030000000000000_00 -0101001E 41701001E0000000_00 -29EB4561 41C4F5A2B0800000_00 -00000020 4040000000000000_00 -8001FFEE C1DFFF8004800000_00 -FFFBDD08 C1108BE000000000_00 -00000040 4050000000000000_00 -FFF03FF9 C12F800E00000000_00 -FFCEDF36 C148906500000000_00 -00000080 4060000000000000_00 -0000F01F 40EE03E000000000_00 -00000279 4083C80000000000_00 -00000100 4070000000000000_00 -BFFFFFEF C1D0000004400000_00 -00000007 401C000000000000_00 -00000200 4080000000000000_00 -010BFFFD 4170BFFFD0000000_00 -FFFFF590 C0A4E00000000000_00 -00000400 4090000000000000_00 -F7FFFEFB C1A000020A000000_00 -2FEA335F 41C7F519AF800000_00 -00000800 40A0000000000000_00 -FFC07FFF C14FC00080000000_00 -177957FD 41B77957FD000000_00 -00001000 40B0000000000000_00 -01FBFFEE 417FBFFEE0000000_00 -FFFFFAC9 C094DC0000000000_00 -00002000 40C0000000000000_00 -FFFF8004 C0DFFF0000000000_00 -FFFBE0DE C1107C8800000000_00 -00004000 40D0000000000000_00 -3F00001E 41CF80000F000000_00 -00000000 0000000000000000_00 -00008000 40E0000000000000_00 -FF8201FF C15F7F8040000000_00 -FFFFD2F1 C0C6878000000000_00 -00010000 40F0000000000000_00 -0000047E 4091F80000000000_00 -0011B7E5 4131B7E500000000_00 -00020000 4100000000000000_00 -02200200 4181001000000000_00 -0013F7E6 4133F7E600000000_00 -00040000 4110000000000000_00 -FFFDC007 C101FFC800000000_00 -FD0ABD9A C187AA1330000000_00 -00080000 4120000000000000_00 -0000607F 40D81FC000000000_00 -00003CEE 40CE770000000000_00 -00100000 4130000000000000_00 -DFDFE000 C1C0101000000000_00 -FFFB1642 C113A6F800000000_00 -00200000 4140000000000000_00 -FC000078 C18FFFFC40000000_00 -5F70EEC1 41D7DC3BB0400000_00 -00400000 4150000000000000_00 -00100082 4130008200000000_00 -FFFFFE21 C07DF00000000000_00 -00800000 4160000000000000_00 -FF7BFF7F C160801020000000_00 -FFFF6393 C0E38DA000000000_00 -01000000 4170000000000000_00 -07EFFEFD 419FBFFBF4000000_00 -FFFFFDB4 C082600000000000_00 -02000000 4180000000000000_00 -8002FFFF C1DFFF4000400000_00 -FFFFC8E2 C0CB8F0000000000_00 -04000000 4190000000000000_00 -FFFC0DFE C10F901000000000_00 -FFFFFF1B C06CA00000000000_00 -08000000 41A0000000000000_00 -03FFFDBF 418FFFEDF8000000_00 -0001092B 40F092B000000000_00 -10000000 41B0000000000000_00 -007FBFFD 415FEFFF40000000_00 -00B4F3D1 41669E7A20000000_00 -20000000 41C0000000000000_00 -FEF801FF C1707FE010000000_00 -00000005 4014000000000000_00 -40000000 41D0000000000000_00 -BFF3FFFE C1D0030000800000_00 -0001806B 40F806B000000000_00 -80000000 C1E0000000000000_00 -0000A07E 40E40FC000000000_00 -FFFFA59F C0D6984000000000_00 -C0000000 C1D0000000000000_00 -E0007FDE C1BFFF8022000000_00 -FFF8343E C11F2F0800000000_00 -E0000000 C1C0000000000000_00 -0000FF7C 40EFEF8000000000_00 -FFFFFFF7 C022000000000000_00 -F0000000 C1B0000000000000_00 -BDFFFFFC C1D0800001000000_00 -FFFFE3C1 C0BC3F0000000000_00 -F8000000 C1A0000000000000_00 -28003FFE 41C4001FFF000000_00 -00000000 0000000000000000_00 -FC000000 C190000000000000_00 -00EEFFFF 416DDFFFE0000000_00 -00003EB0 40CF580000000000_00 -FE000000 C180000000000000_00 -00000F7D 40AEFA0000000000_00 -FFFFFF0F C06E200000000000_00 -FF000000 C170000000000000_00 -0000406D 40D01B4000000000_00 -0000001A 403A000000000000_00 -FF800000 C160000000000000_00 -203FFFFD 41C01FFFFE800000_00 -0000000A 4024000000000000_00 -FFC00000 C150000000000000_00 -FFFF007C C0EFF08000000000_00 -0000009B 4063600000000000_00 -FFE00000 C140000000000000_00 -00E00FFF 416C01FFE0000000_00 -00000006 4018000000000000_00 -FFF00000 C130000000000000_00 -00200FFC 414007FE00000000_00 -00000714 409C500000000000_00 -FFF80000 C120000000000000_00 -F800040E C19FFFEFC8000000_00 -00000013 4033000000000000_00 -FFFC0000 C110000000000000_00 -F83BFFFF C19F100004000000_00 -FFF3F584 C12814F800000000_00 -FFFE0000 C100000000000000_00 -F6FFFBFF C1A2000802000000_00 -FFFFFFF0 C030000000000000_00 -FFFF0000 C0F0000000000000_00 -80003FFD C1DFFFF000C00000_00 -FFFFFFAD C054C00000000000_00 -FFFF8000 C0E0000000000000_00 -004001FD 4150007F40000000_00 -000D734E 412AE69C00000000_00 -FFFFC000 C0D0000000000000_00 -006003FE 415800FF80000000_00 -FF9DBAA8 C158915600000000_00 -FFFFE000 C0C0000000000000_00 -000403EE 41100FB800000000_00 -00734668 415CD19A00000000_00 -FFFFF000 C0B0000000000000_00 -01200002 4172000020000000_00 -FF8874A5 C15DE2D6C0000000_00 -FFFFF800 C0A0000000000000_00 -00060001 4118000400000000_00 -FFFFFFF8 C020000000000000_00 -FFFFFC00 C090000000000000_00 -001FFEDD 413FFEDD00000000_00 -FFFC56DF C10D490800000000_00 -FFFFFE00 C080000000000000_00 -EFFFEFFD C1B0001003000000_00 -FECF5EC6 C1730A13A0000000_00 -FFFFFF00 C070000000000000_00 -1FF00002 41BFF00002000000_00 -F6DB786B C1A2490F2A000000_00 -FFFFFF80 C060000000000000_00 -F0000FBE C1AFFFE084000000_00 -00000009 4022000000000000_00 -FFFFFFC0 C050000000000000_00 -0010801F 4130801F00000000_00 -0001F238 40FF238000000000_00 -FFFFFFE0 C040000000000000_00 -F8000047 C19FFFFEE4000000_00 -0002133C 410099E000000000_00 -FFFFFFF0 C030000000000000_00 -003C001F 414E000F80000000_00 -000001F1 407F100000000000_00 -FFFFFFF8 C020000000000000_00 -FFDFBFFF C140200080000000_00 -FF5E507F C16435F020000000_00 -FFFFFFFC C010000000000000_00 -037FFFDE 418BFFFEF0000000_00 -FFFD7C6F C1041C8800000000_00 -FFFFFFFE C000000000000000_00 -000000FD 406FA00000000000_00 -FFFFF42A C0A7AC0000000000_00 -FFFFFFFF BFF0000000000000_00 -021FFF7D 4180FFFBE8000000_00 -0000000A 4024000000000000_00 -FFFFFFFD C008000000000000_00 -4010FFFF 41D0043FFFC00000_00 -FFFFFFD3 C046800000000000_00 -FFFFFFFB C014000000000000_00 -FFFF800B C0DFFD4000000000_00 -000000B8 4067000000000000_00 -FFFFFFF7 C022000000000000_00 -FF800803 C15FFDFF40000000_00 -FFFFFFFE C000000000000000_00 -FFFFFFEF C031000000000000_00 -00803FFB 416007FF60000000_00 -00000308 4088400000000000_00 -FFFFFFDF C040800000000000_00 -2107FFFE 41C083FFFF000000_00 -FFE15D4F C13EA2B100000000_00 -FFFFFFBF C050400000000000_00 -400087FD 41D00021FF400000_00 -0000000F 402E000000000000_00 -FFFFFF7F C060200000000000_00 -FDFC007E C1801FFC10000000_00 -00000006 4018000000000000_00 -FFFFFEFF C070100000000000_00 -FFF80100 C11FFC0000000000_00 -FFFFFE99 C076700000000000_00 -FFFFFDFF C080080000000000_00 -03000002 4188000010000000_00 -FFF716EA C121D22C00000000_00 -FFFFFBFF C090040000000000_00 -C7FDFFFF C1CC010000800000_00 -FFFFE327 C0BCD90000000000_00 -FFFFF7FF C0A0020000000000_00 -0103DFFE 41703DFFE0000000_00 -07661FD8 419D987F60000000_00 -FFFFEFFF C0B0010000000000_00 -83FFFFFE C1DF000000800000_00 -FCD956DB C189354928000000_00 -FFFFDFFF C0C0008000000000_00 -FF2001FD C16BFFC060000000_00 -E4D35BBF C1BB2CA441000000_00 -FFFFBFFF C0D0004000000000_00 -DFEFEFFE C1C0080801000000_00 -05DA4300 4197690C00000000_00 -FFFF7FFF C0E0002000000000_00 -40001040 41D0000410000000_00 -812EDF40 C1DFB44830000000_00 -FFFEFFFF C0F0001000000000_00 -FFFFC007 C0CFFC8000000000_00 -00B6FCC9 4166DF9920000000_00 -FFFDFFFF C100000800000000_00 -000007FE 409FF80000000000_00 -FC3DE950 C18E10B580000000_00 -FFFBFFFF C110000400000000_00 -7FFFFE03 41DFFFFF80C00000_00 -FEB02B59 C174FD4A70000000_00 -FFF7FFFF C120000200000000_00 -10FF7FFF 41B0FF7FFF000000_00 -00008D5E 40E1ABC000000000_00 -FFEFFFFF C130000100000000_00 -FFFF007E C0EFF04000000000_00 -001C2108 413C210800000000_00 -FFDFFFFF C140000080000000_00 -00FFC001 416FF80020000000_00 -F01C6B36 C1AFC72994000000_00 -FFBFFFFF C150000040000000_00 -FFFF7FFF C0E0002000000000_00 -FFFFD055 C0C7D58000000000_00 -FF7FFFFF C160000020000000_00 -027BFFFE 4183DFFFF0000000_00 -FF3090D0 C169EDE600000000_00 -FEFFFFFF C170000010000000_00 -00082040 4120408000000000_00 -0000006E 405B800000000000_00 -FDFFFFFF C180000008000000_00 -FDFFFF87 C1800003C8000000_00 -04C3764D 41930DD934000000_00 -FBFFFFFF C190000004000000_00 -0006007E 411801F800000000_00 -000001EF 407EF00000000000_00 -F7FFFFFF C1A0000002000000_00 -FFBF7FFE C150200080000000_00 -FF1C4E5A C16C7634C0000000_00 -EFFFFFFF C1B0000001000000_00 -FFF97FFD C11A000C00000000_00 -000001D1 407D100000000000_00 -DFFFFFFF C1C0000000800000_00 -2FFFFFFE 41C7FFFFFF000000_00 -00136721 4133672100000000_00 -BFFFFFFF C1D0000000400000_00 -00004BFF 40D2FFC000000000_00 -00000544 4095100000000000_00 -7FFFFFFF 41DFFFFFFFC00000_00 -007FDFFB 415FF7FEC0000000_00 -FFF8BD5E C11D0A8800000000_00 -3FFFFFFF 41CFFFFFFF800000_00 -FFBF8003 C1501FFF40000000_00 -FFFE45D2 C0FBA2E000000000_00 -1FFFFFFF 41BFFFFFFF000000_00 -FFFFFDBF C082080000000000_00 -FFFFF189 C0ACEE0000000000_00 -0FFFFFFF 41AFFFFFFE000000_00 -FFFE6FFE C0F9002000000000_00 -FC8672A0 C18BCC6B00000000_00 -07FFFFFF 419FFFFFFC000000_00 -00000107 4070700000000000_00 -FFFCCA70 C109AC8000000000_00 -03FFFFFF 418FFFFFF8000000_00 -002107FE 414083FF00000000_00 -FFFF48E7 C0E6E32000000000_00 -01FFFFFF 417FFFFFF0000000_00 -F7FDFFEE C1A0040024000000_00 -00000010 4030000000000000_00 -00FFFFFF 416FFFFFE0000000_00 -FFFF01FD C0EFC06000000000_00 -0000FAEF 40EF5DE000000000_00 -007FFFFF 415FFFFFC0000000_00 -00FC0001 416F800020000000_00 -000000F5 406EA00000000000_00 -003FFFFF 414FFFFF80000000_00 -FFE07FC0 C13F804000000000_00 -001AFFFB 413AFFFB00000000_00 -001FFFFF 413FFFFF00000000_00 -00101FFD 41301FFD00000000_00 -FF4613B2 C1673D89C0000000_00 -000FFFFF 412FFFFE00000000_00 -F00005FE C1AFFFF404000000_00 -00036402 410B201000000000_00 -0007FFFF 411FFFFC00000000_00 -0404FFFF 419013FFFC000000_00 -021C2358 4180E11AC0000000_00 -0003FFFF 410FFFF800000000_00 -FFFFFD02 C087F00000000000_00 -FFFF41C6 C0E7C74000000000_00 -0001FFFF 40FFFFF000000000_00 -00000007 401C000000000000_00 -27F174DE 41C3F8BA6F000000_00 -0000FFFF 40EFFFE000000000_00 -000083F5 40E07EA000000000_00 -FFFFFFFB C014000000000000_00 -00007FFF 40DFFFC000000000_00 -FE7FDFFE C178020020000000_00 -FFFFFFFD C008000000000000_00 -00003FFF 40CFFF8000000000_00 -DBBFFFFE C1C2200001000000_00 -00000404 4090100000000000_00 -00001FFF 40BFFF0000000000_00 -FFFFC018 C0CFF40000000000_00 -00002853 40C4298000000000_00 -00000FFF 40AFFE0000000000_00 -03FE007F 418FF003F8000000_00 -FFFFF124 C0ADB80000000000_00 -000007FF 409FFC0000000000_00 -FFFFEFBE C0B0420000000000_00 -FFFB9AD8 C11194A000000000_00 -000003FF 408FF80000000000_00 -DFFFFDFE C1C0000101000000_00 -FFFFFD95 C083580000000000_00 -000001FF 407FF00000000000_00 -FDFFFFFF C180000008000000_00 -FFFFFFD0 C048000000000000_00 -000000FF 406FE00000000000_00 -0037FFE0 414BFFF000000000_00 -010EC496 4170EC4960000000_00 -0000007F 405FC00000000000_00 -B8007FFF C1D1FFE000400000_00 -00000012 4032000000000000_00 -0000003F 404F800000000000_00 -02003FFC 418001FFE0000000_00 -FFFFFFEF C031000000000000_00 -0000001F 403F000000000000_00 -FF7FFF02 C160001FC0000000_00 -FFFFE2CE C0BD320000000000_00 -0000000F 402E000000000000_00 -0000A00D 40E401A000000000_00 -FFFFFE44 C07BC00000000000_00 -00000007 401C000000000000_00 -0003FFFA 410FFFD000000000_00 -000038E7 40CC738000000000_00 -00000003 4008000000000000_00 +1FEFFFEF_41BFEFFFEF000000_00 +FFFFC48E_C0CDB90000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00009E14_40E3C28000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +FFFFDE38_C0C0E40000000000_00 +00000002_4000000000000000_00 +FFDFFC02_C14001FF00000000_00 +FB794C79_C1921ACE1C000000_00 +00000004_4010000000000000_00 +F00FFFFE_C1AFE00004000000_00 +00000A95_40A52A0000000000_00 +00000008_4020000000000000_00 +FFFFF97F_C09A040000000000_00 +FFAE458D_C1546E9CC0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +29EB4561_41C4F5A2B0800000_00 +00000020_4040000000000000_00 +8001FFEE_C1DFFF8004800000_00 +FFFBDD08_C1108BE000000000_00 +00000040_4050000000000000_00 +FFF03FF9_C12F800E00000000_00 +FFCEDF36_C148906500000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000279_4083C80000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_C1D0000004400000_00 +00000007_401C000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +FFFFF590_C0A4E00000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_C1A000020A000000_00 +2FEA335F_41C7F519AF800000_00 +00000800_40A0000000000000_00 +FFC07FFF_C14FC00080000000_00 +177957FD_41B77957FD000000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +FFFFFAC9_C094DC0000000000_00 +00002000_40C0000000000000_00 +FFFF8004_C0DFFF0000000000_00 +FFFBE0DE_C1107C8800000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000000_0000000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_C15F7F8040000000_00 +FFFFD2F1_C0C6878000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0011B7E5_4131B7E500000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0013F7E6_4133F7E600000000_00 +00040000_4110000000000000_00 +FFFDC007_C101FFC800000000_00 +FD0ABD9A_C187AA1330000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00003CEE_40CE770000000000_00 +00100000_4130000000000000_00 +DFDFE000_C1C0101000000000_00 +FFFB1642_C113A6F800000000_00 +00200000_4140000000000000_00 +FC000078_C18FFFFC40000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +FFFFFE21_C07DF00000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_C160801020000000_00 +FFFF6393_C0E38DA000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +FFFFFDB4_C082600000000000_00 +02000000_4180000000000000_00 +8002FFFF_C1DFFF4000400000_00 +FFFFC8E2_C0CB8F0000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_C10F901000000000_00 +FFFFFF1B_C06CA00000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0001092B_40F092B000000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +00B4F3D1_41669E7A20000000_00 +20000000_41C0000000000000_00 +FEF801FF_C1707FE010000000_00 +00000005_4014000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_C1D0030000800000_00 +0001806B_40F806B000000000_00 +80000000_C1E0000000000000_00 +0000A07E_40E40FC000000000_00 +FFFFA59F_C0D6984000000000_00 +C0000000_C1D0000000000000_00 +E0007FDE_C1BFFF8022000000_00 +FFF8343E_C11F2F0800000000_00 +E0000000_C1C0000000000000_00 +0000FF7C_40EFEF8000000000_00 +FFFFFFF7_C022000000000000_00 +F0000000_C1B0000000000000_00 +BDFFFFFC_C1D0800001000000_00 +FFFFE3C1_C0BC3F0000000000_00 +F8000000_C1A0000000000000_00 +28003FFE_41C4001FFF000000_00 +00000000_0000000000000000_00 +FC000000_C190000000000000_00 +00EEFFFF_416DDFFFE0000000_00 +00003EB0_40CF580000000000_00 +FE000000_C180000000000000_00 +00000F7D_40AEFA0000000000_00 +FFFFFF0F_C06E200000000000_00 +FF000000_C170000000000000_00 +0000406D_40D01B4000000000_00 +0000001A_403A000000000000_00 +FF800000_C160000000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000000A_4024000000000000_00 +FFC00000_C150000000000000_00 +FFFF007C_C0EFF08000000000_00 +0000009B_4063600000000000_00 +FFE00000_C140000000000000_00 +00E00FFF_416C01FFE0000000_00 +00000006_4018000000000000_00 +FFF00000_C130000000000000_00 +00200FFC_414007FE00000000_00 +00000714_409C500000000000_00 +FFF80000_C120000000000000_00 +F800040E_C19FFFEFC8000000_00 +00000013_4033000000000000_00 +FFFC0000_C110000000000000_00 +F83BFFFF_C19F100004000000_00 +FFF3F584_C12814F800000000_00 +FFFE0000_C100000000000000_00 +F6FFFBFF_C1A2000802000000_00 +FFFFFFF0_C030000000000000_00 +FFFF0000_C0F0000000000000_00 +80003FFD_C1DFFFF000C00000_00 +FFFFFFAD_C054C00000000000_00 +FFFF8000_C0E0000000000000_00 +004001FD_4150007F40000000_00 +000D734E_412AE69C00000000_00 +FFFFC000_C0D0000000000000_00 +006003FE_415800FF80000000_00 +FF9DBAA8_C158915600000000_00 +FFFFE000_C0C0000000000000_00 +000403EE_41100FB800000000_00 +00734668_415CD19A00000000_00 +FFFFF000_C0B0000000000000_00 +01200002_4172000020000000_00 +FF8874A5_C15DE2D6C0000000_00 +FFFFF800_C0A0000000000000_00 +00060001_4118000400000000_00 +FFFFFFF8_C020000000000000_00 +FFFFFC00_C090000000000000_00 +001FFEDD_413FFEDD00000000_00 +FFFC56DF_C10D490800000000_00 +FFFFFE00_C080000000000000_00 +EFFFEFFD_C1B0001003000000_00 +FECF5EC6_C1730A13A0000000_00 +FFFFFF00_C070000000000000_00 +1FF00002_41BFF00002000000_00 +F6DB786B_C1A2490F2A000000_00 +FFFFFF80_C060000000000000_00 +F0000FBE_C1AFFFE084000000_00 +00000009_4022000000000000_00 +FFFFFFC0_C050000000000000_00 +0010801F_4130801F00000000_00 +0001F238_40FF238000000000_00 +FFFFFFE0_C040000000000000_00 +F8000047_C19FFFFEE4000000_00 +0002133C_410099E000000000_00 +FFFFFFF0_C030000000000000_00 +003C001F_414E000F80000000_00 +000001F1_407F100000000000_00 +FFFFFFF8_C020000000000000_00 +FFDFBFFF_C140200080000000_00 +FF5E507F_C16435F020000000_00 +FFFFFFFC_C010000000000000_00 +037FFFDE_418BFFFEF0000000_00 +FFFD7C6F_C1041C8800000000_00 +FFFFFFFE_C000000000000000_00 +000000FD_406FA00000000000_00 +FFFFF42A_C0A7AC0000000000_00 +FFFFFFFF_BFF0000000000000_00 +021FFF7D_4180FFFBE8000000_00 +0000000A_4024000000000000_00 +FFFFFFFD_C008000000000000_00 +4010FFFF_41D0043FFFC00000_00 +FFFFFFD3_C046800000000000_00 +FFFFFFFB_C014000000000000_00 +FFFF800B_C0DFFD4000000000_00 +000000B8_4067000000000000_00 +FFFFFFF7_C022000000000000_00 +FF800803_C15FFDFF40000000_00 +FFFFFFFE_C000000000000000_00 +FFFFFFEF_C031000000000000_00 +00803FFB_416007FF60000000_00 +00000308_4088400000000000_00 +FFFFFFDF_C040800000000000_00 +2107FFFE_41C083FFFF000000_00 +FFE15D4F_C13EA2B100000000_00 +FFFFFFBF_C050400000000000_00 +400087FD_41D00021FF400000_00 +0000000F_402E000000000000_00 +FFFFFF7F_C060200000000000_00 +FDFC007E_C1801FFC10000000_00 +00000006_4018000000000000_00 +FFFFFEFF_C070100000000000_00 +FFF80100_C11FFC0000000000_00 +FFFFFE99_C076700000000000_00 +FFFFFDFF_C080080000000000_00 +03000002_4188000010000000_00 +FFF716EA_C121D22C00000000_00 +FFFFFBFF_C090040000000000_00 +C7FDFFFF_C1CC010000800000_00 +FFFFE327_C0BCD90000000000_00 +FFFFF7FF_C0A0020000000000_00 +0103DFFE_41703DFFE0000000_00 +07661FD8_419D987F60000000_00 +FFFFEFFF_C0B0010000000000_00 +83FFFFFE_C1DF000000800000_00 +FCD956DB_C189354928000000_00 +FFFFDFFF_C0C0008000000000_00 +FF2001FD_C16BFFC060000000_00 +E4D35BBF_C1BB2CA441000000_00 +FFFFBFFF_C0D0004000000000_00 +DFEFEFFE_C1C0080801000000_00 +05DA4300_4197690C00000000_00 +FFFF7FFF_C0E0002000000000_00 +40001040_41D0000410000000_00 +812EDF40_C1DFB44830000000_00 +FFFEFFFF_C0F0001000000000_00 +FFFFC007_C0CFFC8000000000_00 +00B6FCC9_4166DF9920000000_00 +FFFDFFFF_C100000800000000_00 +000007FE_409FF80000000000_00 +FC3DE950_C18E10B580000000_00 +FFFBFFFF_C110000400000000_00 +7FFFFE03_41DFFFFF80C00000_00 +FEB02B59_C174FD4A70000000_00 +FFF7FFFF_C120000200000000_00 +10FF7FFF_41B0FF7FFF000000_00 +00008D5E_40E1ABC000000000_00 +FFEFFFFF_C130000100000000_00 +FFFF007E_C0EFF04000000000_00 +001C2108_413C210800000000_00 +FFDFFFFF_C140000080000000_00 +00FFC001_416FF80020000000_00 +F01C6B36_C1AFC72994000000_00 +FFBFFFFF_C150000040000000_00 +FFFF7FFF_C0E0002000000000_00 +FFFFD055_C0C7D58000000000_00 +FF7FFFFF_C160000020000000_00 +027BFFFE_4183DFFFF0000000_00 +FF3090D0_C169EDE600000000_00 +FEFFFFFF_C170000010000000_00 +00082040_4120408000000000_00 +0000006E_405B800000000000_00 +FDFFFFFF_C180000008000000_00 +FDFFFF87_C1800003C8000000_00 +04C3764D_41930DD934000000_00 +FBFFFFFF_C190000004000000_00 +0006007E_411801F800000000_00 +000001EF_407EF00000000000_00 +F7FFFFFF_C1A0000002000000_00 +FFBF7FFE_C150200080000000_00 +FF1C4E5A_C16C7634C0000000_00 +EFFFFFFF_C1B0000001000000_00 +FFF97FFD_C11A000C00000000_00 +000001D1_407D100000000000_00 +DFFFFFFF_C1C0000000800000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00136721_4133672100000000_00 +BFFFFFFF_C1D0000000400000_00 +00004BFF_40D2FFC000000000_00 +00000544_4095100000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +FFF8BD5E_C11D0A8800000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_C1501FFF40000000_00 +FFFE45D2_C0FBA2E000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_C082080000000000_00 +FFFFF189_C0ACEE0000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_C0F9002000000000_00 +FC8672A0_C18BCC6B00000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +FFFCCA70_C109AC8000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +FFFF48E7_C0E6E32000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_C1A0040024000000_00 +00000010_4030000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_C0EFC06000000000_00 +0000FAEF_40EF5DE000000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000000F5_406EA00000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_C13F804000000000_00 +001AFFFB_413AFFFB00000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +FF4613B2_C1673D89C0000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_C1AFFFF404000000_00 +00036402_410B201000000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_C087F00000000000_00 +FFFF41C6_C0E7C74000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +FFFFFFFB_C014000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_C178020020000000_00 +FFFFFFFD_C008000000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_C1C2200001000000_00 +00000404_4090100000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_C0CFF40000000000_00 +00002853_40C4298000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +FFFFF124_C0ADB80000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_C0B0420000000000_00 +FFFB9AD8_C11194A000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_C1C0000101000000_00 +FFFFFD95_C083580000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_C180000008000000_00 +FFFFFFD0_C048000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +010EC496_4170EC4960000000_00 +0000007F_405FC00000000000_00 +B8007FFF_C1D1FFE000400000_00 +00000012_4032000000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +FFFFFFEF_C031000000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_C160001FC0000000_00 +FFFFE2CE_C0BD320000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +FFFFFE44_C07BC00000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +000038E7_40CC738000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i32_f64_rz.tv b/wally-pipelined/testbench/fp/i32_f64_rz.tv index 7f04b63fd..3e4622082 100644 --- a/wally-pipelined/testbench/fp/i32_f64_rz.tv +++ b/wally-pipelined/testbench/fp/i32_f64_rz.tv @@ -1,372 +1,372 @@ -1FEFFFEF 41BFEFFFEF000000_00 -FFFFC48E C0CDB90000000000_00 -00000000 0000000000000000_00 -007FFFCD 415FFFF340000000_00 -00009E14 40E3C28000000000_00 -00000001 3FF0000000000000_00 -001FFFFB 413FFFFB00000000_00 -FFFFDE38 C0C0E40000000000_00 -00000002 4000000000000000_00 -FFDFFC02 C14001FF00000000_00 -FB794C79 C1921ACE1C000000_00 -00000004 4010000000000000_00 -F00FFFFE C1AFE00004000000_00 -00000A95 40A52A0000000000_00 -00000008 4020000000000000_00 -FFFFF97F C09A040000000000_00 -FFAE458D C1546E9CC0000000_00 -00000010 4030000000000000_00 -0101001E 41701001E0000000_00 -29EB4561 41C4F5A2B0800000_00 -00000020 4040000000000000_00 -8001FFEE C1DFFF8004800000_00 -FFFBDD08 C1108BE000000000_00 -00000040 4050000000000000_00 -FFF03FF9 C12F800E00000000_00 -FFCEDF36 C148906500000000_00 -00000080 4060000000000000_00 -0000F01F 40EE03E000000000_00 -00000279 4083C80000000000_00 -00000100 4070000000000000_00 -BFFFFFEF C1D0000004400000_00 -00000007 401C000000000000_00 -00000200 4080000000000000_00 -010BFFFD 4170BFFFD0000000_00 -FFFFF590 C0A4E00000000000_00 -00000400 4090000000000000_00 -F7FFFEFB C1A000020A000000_00 -2FEA335F 41C7F519AF800000_00 -00000800 40A0000000000000_00 -FFC07FFF C14FC00080000000_00 -177957FD 41B77957FD000000_00 -00001000 40B0000000000000_00 -01FBFFEE 417FBFFEE0000000_00 -FFFFFAC9 C094DC0000000000_00 -00002000 40C0000000000000_00 -FFFF8004 C0DFFF0000000000_00 -FFFBE0DE C1107C8800000000_00 -00004000 40D0000000000000_00 -3F00001E 41CF80000F000000_00 -00000000 0000000000000000_00 -00008000 40E0000000000000_00 -FF8201FF C15F7F8040000000_00 -FFFFD2F1 C0C6878000000000_00 -00010000 40F0000000000000_00 -0000047E 4091F80000000000_00 -0011B7E5 4131B7E500000000_00 -00020000 4100000000000000_00 -02200200 4181001000000000_00 -0013F7E6 4133F7E600000000_00 -00040000 4110000000000000_00 -FFFDC007 C101FFC800000000_00 -FD0ABD9A C187AA1330000000_00 -00080000 4120000000000000_00 -0000607F 40D81FC000000000_00 -00003CEE 40CE770000000000_00 -00100000 4130000000000000_00 -DFDFE000 C1C0101000000000_00 -FFFB1642 C113A6F800000000_00 -00200000 4140000000000000_00 -FC000078 C18FFFFC40000000_00 -5F70EEC1 41D7DC3BB0400000_00 -00400000 4150000000000000_00 -00100082 4130008200000000_00 -FFFFFE21 C07DF00000000000_00 -00800000 4160000000000000_00 -FF7BFF7F C160801020000000_00 -FFFF6393 C0E38DA000000000_00 -01000000 4170000000000000_00 -07EFFEFD 419FBFFBF4000000_00 -FFFFFDB4 C082600000000000_00 -02000000 4180000000000000_00 -8002FFFF C1DFFF4000400000_00 -FFFFC8E2 C0CB8F0000000000_00 -04000000 4190000000000000_00 -FFFC0DFE C10F901000000000_00 -FFFFFF1B C06CA00000000000_00 -08000000 41A0000000000000_00 -03FFFDBF 418FFFEDF8000000_00 -0001092B 40F092B000000000_00 -10000000 41B0000000000000_00 -007FBFFD 415FEFFF40000000_00 -00B4F3D1 41669E7A20000000_00 -20000000 41C0000000000000_00 -FEF801FF C1707FE010000000_00 -00000005 4014000000000000_00 -40000000 41D0000000000000_00 -BFF3FFFE C1D0030000800000_00 -0001806B 40F806B000000000_00 -80000000 C1E0000000000000_00 -0000A07E 40E40FC000000000_00 -FFFFA59F C0D6984000000000_00 -C0000000 C1D0000000000000_00 -E0007FDE C1BFFF8022000000_00 -FFF8343E C11F2F0800000000_00 -E0000000 C1C0000000000000_00 -0000FF7C 40EFEF8000000000_00 -FFFFFFF7 C022000000000000_00 -F0000000 C1B0000000000000_00 -BDFFFFFC C1D0800001000000_00 -FFFFE3C1 C0BC3F0000000000_00 -F8000000 C1A0000000000000_00 -28003FFE 41C4001FFF000000_00 -00000000 0000000000000000_00 -FC000000 C190000000000000_00 -00EEFFFF 416DDFFFE0000000_00 -00003EB0 40CF580000000000_00 -FE000000 C180000000000000_00 -00000F7D 40AEFA0000000000_00 -FFFFFF0F C06E200000000000_00 -FF000000 C170000000000000_00 -0000406D 40D01B4000000000_00 -0000001A 403A000000000000_00 -FF800000 C160000000000000_00 -203FFFFD 41C01FFFFE800000_00 -0000000A 4024000000000000_00 -FFC00000 C150000000000000_00 -FFFF007C C0EFF08000000000_00 -0000009B 4063600000000000_00 -FFE00000 C140000000000000_00 -00E00FFF 416C01FFE0000000_00 -00000006 4018000000000000_00 -FFF00000 C130000000000000_00 -00200FFC 414007FE00000000_00 -00000714 409C500000000000_00 -FFF80000 C120000000000000_00 -F800040E C19FFFEFC8000000_00 -00000013 4033000000000000_00 -FFFC0000 C110000000000000_00 -F83BFFFF C19F100004000000_00 -FFF3F584 C12814F800000000_00 -FFFE0000 C100000000000000_00 -F6FFFBFF C1A2000802000000_00 -FFFFFFF0 C030000000000000_00 -FFFF0000 C0F0000000000000_00 -80003FFD C1DFFFF000C00000_00 -FFFFFFAD C054C00000000000_00 -FFFF8000 C0E0000000000000_00 -004001FD 4150007F40000000_00 -000D734E 412AE69C00000000_00 -FFFFC000 C0D0000000000000_00 -006003FE 415800FF80000000_00 -FF9DBAA8 C158915600000000_00 -FFFFE000 C0C0000000000000_00 -000403EE 41100FB800000000_00 -00734668 415CD19A00000000_00 -FFFFF000 C0B0000000000000_00 -01200002 4172000020000000_00 -FF8874A5 C15DE2D6C0000000_00 -FFFFF800 C0A0000000000000_00 -00060001 4118000400000000_00 -FFFFFFF8 C020000000000000_00 -FFFFFC00 C090000000000000_00 -001FFEDD 413FFEDD00000000_00 -FFFC56DF C10D490800000000_00 -FFFFFE00 C080000000000000_00 -EFFFEFFD C1B0001003000000_00 -FECF5EC6 C1730A13A0000000_00 -FFFFFF00 C070000000000000_00 -1FF00002 41BFF00002000000_00 -F6DB786B C1A2490F2A000000_00 -FFFFFF80 C060000000000000_00 -F0000FBE C1AFFFE084000000_00 -00000009 4022000000000000_00 -FFFFFFC0 C050000000000000_00 -0010801F 4130801F00000000_00 -0001F238 40FF238000000000_00 -FFFFFFE0 C040000000000000_00 -F8000047 C19FFFFEE4000000_00 -0002133C 410099E000000000_00 -FFFFFFF0 C030000000000000_00 -003C001F 414E000F80000000_00 -000001F1 407F100000000000_00 -FFFFFFF8 C020000000000000_00 -FFDFBFFF C140200080000000_00 -FF5E507F C16435F020000000_00 -FFFFFFFC C010000000000000_00 -037FFFDE 418BFFFEF0000000_00 -FFFD7C6F C1041C8800000000_00 -FFFFFFFE C000000000000000_00 -000000FD 406FA00000000000_00 -FFFFF42A C0A7AC0000000000_00 -FFFFFFFF BFF0000000000000_00 -021FFF7D 4180FFFBE8000000_00 -0000000A 4024000000000000_00 -FFFFFFFD C008000000000000_00 -4010FFFF 41D0043FFFC00000_00 -FFFFFFD3 C046800000000000_00 -FFFFFFFB C014000000000000_00 -FFFF800B C0DFFD4000000000_00 -000000B8 4067000000000000_00 -FFFFFFF7 C022000000000000_00 -FF800803 C15FFDFF40000000_00 -FFFFFFFE C000000000000000_00 -FFFFFFEF C031000000000000_00 -00803FFB 416007FF60000000_00 -00000308 4088400000000000_00 -FFFFFFDF C040800000000000_00 -2107FFFE 41C083FFFF000000_00 -FFE15D4F C13EA2B100000000_00 -FFFFFFBF C050400000000000_00 -400087FD 41D00021FF400000_00 -0000000F 402E000000000000_00 -FFFFFF7F C060200000000000_00 -FDFC007E C1801FFC10000000_00 -00000006 4018000000000000_00 -FFFFFEFF C070100000000000_00 -FFF80100 C11FFC0000000000_00 -FFFFFE99 C076700000000000_00 -FFFFFDFF C080080000000000_00 -03000002 4188000010000000_00 -FFF716EA C121D22C00000000_00 -FFFFFBFF C090040000000000_00 -C7FDFFFF C1CC010000800000_00 -FFFFE327 C0BCD90000000000_00 -FFFFF7FF C0A0020000000000_00 -0103DFFE 41703DFFE0000000_00 -07661FD8 419D987F60000000_00 -FFFFEFFF C0B0010000000000_00 -83FFFFFE C1DF000000800000_00 -FCD956DB C189354928000000_00 -FFFFDFFF C0C0008000000000_00 -FF2001FD C16BFFC060000000_00 -E4D35BBF C1BB2CA441000000_00 -FFFFBFFF C0D0004000000000_00 -DFEFEFFE C1C0080801000000_00 -05DA4300 4197690C00000000_00 -FFFF7FFF C0E0002000000000_00 -40001040 41D0000410000000_00 -812EDF40 C1DFB44830000000_00 -FFFEFFFF C0F0001000000000_00 -FFFFC007 C0CFFC8000000000_00 -00B6FCC9 4166DF9920000000_00 -FFFDFFFF C100000800000000_00 -000007FE 409FF80000000000_00 -FC3DE950 C18E10B580000000_00 -FFFBFFFF C110000400000000_00 -7FFFFE03 41DFFFFF80C00000_00 -FEB02B59 C174FD4A70000000_00 -FFF7FFFF C120000200000000_00 -10FF7FFF 41B0FF7FFF000000_00 -00008D5E 40E1ABC000000000_00 -FFEFFFFF C130000100000000_00 -FFFF007E C0EFF04000000000_00 -001C2108 413C210800000000_00 -FFDFFFFF C140000080000000_00 -00FFC001 416FF80020000000_00 -F01C6B36 C1AFC72994000000_00 -FFBFFFFF C150000040000000_00 -FFFF7FFF C0E0002000000000_00 -FFFFD055 C0C7D58000000000_00 -FF7FFFFF C160000020000000_00 -027BFFFE 4183DFFFF0000000_00 -FF3090D0 C169EDE600000000_00 -FEFFFFFF C170000010000000_00 -00082040 4120408000000000_00 -0000006E 405B800000000000_00 -FDFFFFFF C180000008000000_00 -FDFFFF87 C1800003C8000000_00 -04C3764D 41930DD934000000_00 -FBFFFFFF C190000004000000_00 -0006007E 411801F800000000_00 -000001EF 407EF00000000000_00 -F7FFFFFF C1A0000002000000_00 -FFBF7FFE C150200080000000_00 -FF1C4E5A C16C7634C0000000_00 -EFFFFFFF C1B0000001000000_00 -FFF97FFD C11A000C00000000_00 -000001D1 407D100000000000_00 -DFFFFFFF C1C0000000800000_00 -2FFFFFFE 41C7FFFFFF000000_00 -00136721 4133672100000000_00 -BFFFFFFF C1D0000000400000_00 -00004BFF 40D2FFC000000000_00 -00000544 4095100000000000_00 -7FFFFFFF 41DFFFFFFFC00000_00 -007FDFFB 415FF7FEC0000000_00 -FFF8BD5E C11D0A8800000000_00 -3FFFFFFF 41CFFFFFFF800000_00 -FFBF8003 C1501FFF40000000_00 -FFFE45D2 C0FBA2E000000000_00 -1FFFFFFF 41BFFFFFFF000000_00 -FFFFFDBF C082080000000000_00 -FFFFF189 C0ACEE0000000000_00 -0FFFFFFF 41AFFFFFFE000000_00 -FFFE6FFE C0F9002000000000_00 -FC8672A0 C18BCC6B00000000_00 -07FFFFFF 419FFFFFFC000000_00 -00000107 4070700000000000_00 -FFFCCA70 C109AC8000000000_00 -03FFFFFF 418FFFFFF8000000_00 -002107FE 414083FF00000000_00 -FFFF48E7 C0E6E32000000000_00 -01FFFFFF 417FFFFFF0000000_00 -F7FDFFEE C1A0040024000000_00 -00000010 4030000000000000_00 -00FFFFFF 416FFFFFE0000000_00 -FFFF01FD C0EFC06000000000_00 -0000FAEF 40EF5DE000000000_00 -007FFFFF 415FFFFFC0000000_00 -00FC0001 416F800020000000_00 -000000F5 406EA00000000000_00 -003FFFFF 414FFFFF80000000_00 -FFE07FC0 C13F804000000000_00 -001AFFFB 413AFFFB00000000_00 -001FFFFF 413FFFFF00000000_00 -00101FFD 41301FFD00000000_00 -FF4613B2 C1673D89C0000000_00 -000FFFFF 412FFFFE00000000_00 -F00005FE C1AFFFF404000000_00 -00036402 410B201000000000_00 -0007FFFF 411FFFFC00000000_00 -0404FFFF 419013FFFC000000_00 -021C2358 4180E11AC0000000_00 -0003FFFF 410FFFF800000000_00 -FFFFFD02 C087F00000000000_00 -FFFF41C6 C0E7C74000000000_00 -0001FFFF 40FFFFF000000000_00 -00000007 401C000000000000_00 -27F174DE 41C3F8BA6F000000_00 -0000FFFF 40EFFFE000000000_00 -000083F5 40E07EA000000000_00 -FFFFFFFB C014000000000000_00 -00007FFF 40DFFFC000000000_00 -FE7FDFFE C178020020000000_00 -FFFFFFFD C008000000000000_00 -00003FFF 40CFFF8000000000_00 -DBBFFFFE C1C2200001000000_00 -00000404 4090100000000000_00 -00001FFF 40BFFF0000000000_00 -FFFFC018 C0CFF40000000000_00 -00002853 40C4298000000000_00 -00000FFF 40AFFE0000000000_00 -03FE007F 418FF003F8000000_00 -FFFFF124 C0ADB80000000000_00 -000007FF 409FFC0000000000_00 -FFFFEFBE C0B0420000000000_00 -FFFB9AD8 C11194A000000000_00 -000003FF 408FF80000000000_00 -DFFFFDFE C1C0000101000000_00 -FFFFFD95 C083580000000000_00 -000001FF 407FF00000000000_00 -FDFFFFFF C180000008000000_00 -FFFFFFD0 C048000000000000_00 -000000FF 406FE00000000000_00 -0037FFE0 414BFFF000000000_00 -010EC496 4170EC4960000000_00 -0000007F 405FC00000000000_00 -B8007FFF C1D1FFE000400000_00 -00000012 4032000000000000_00 -0000003F 404F800000000000_00 -02003FFC 418001FFE0000000_00 -FFFFFFEF C031000000000000_00 -0000001F 403F000000000000_00 -FF7FFF02 C160001FC0000000_00 -FFFFE2CE C0BD320000000000_00 -0000000F 402E000000000000_00 -0000A00D 40E401A000000000_00 -FFFFFE44 C07BC00000000000_00 -00000007 401C000000000000_00 -0003FFFA 410FFFD000000000_00 -000038E7 40CC738000000000_00 -00000003 4008000000000000_00 +1FEFFFEF_41BFEFFFEF000000_00 +FFFFC48E_C0CDB90000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00009E14_40E3C28000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +FFFFDE38_C0C0E40000000000_00 +00000002_4000000000000000_00 +FFDFFC02_C14001FF00000000_00 +FB794C79_C1921ACE1C000000_00 +00000004_4010000000000000_00 +F00FFFFE_C1AFE00004000000_00 +00000A95_40A52A0000000000_00 +00000008_4020000000000000_00 +FFFFF97F_C09A040000000000_00 +FFAE458D_C1546E9CC0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +29EB4561_41C4F5A2B0800000_00 +00000020_4040000000000000_00 +8001FFEE_C1DFFF8004800000_00 +FFFBDD08_C1108BE000000000_00 +00000040_4050000000000000_00 +FFF03FF9_C12F800E00000000_00 +FFCEDF36_C148906500000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000279_4083C80000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_C1D0000004400000_00 +00000007_401C000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +FFFFF590_C0A4E00000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_C1A000020A000000_00 +2FEA335F_41C7F519AF800000_00 +00000800_40A0000000000000_00 +FFC07FFF_C14FC00080000000_00 +177957FD_41B77957FD000000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +FFFFFAC9_C094DC0000000000_00 +00002000_40C0000000000000_00 +FFFF8004_C0DFFF0000000000_00 +FFFBE0DE_C1107C8800000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000000_0000000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_C15F7F8040000000_00 +FFFFD2F1_C0C6878000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0011B7E5_4131B7E500000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0013F7E6_4133F7E600000000_00 +00040000_4110000000000000_00 +FFFDC007_C101FFC800000000_00 +FD0ABD9A_C187AA1330000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00003CEE_40CE770000000000_00 +00100000_4130000000000000_00 +DFDFE000_C1C0101000000000_00 +FFFB1642_C113A6F800000000_00 +00200000_4140000000000000_00 +FC000078_C18FFFFC40000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +FFFFFE21_C07DF00000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_C160801020000000_00 +FFFF6393_C0E38DA000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +FFFFFDB4_C082600000000000_00 +02000000_4180000000000000_00 +8002FFFF_C1DFFF4000400000_00 +FFFFC8E2_C0CB8F0000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_C10F901000000000_00 +FFFFFF1B_C06CA00000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0001092B_40F092B000000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +00B4F3D1_41669E7A20000000_00 +20000000_41C0000000000000_00 +FEF801FF_C1707FE010000000_00 +00000005_4014000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_C1D0030000800000_00 +0001806B_40F806B000000000_00 +80000000_C1E0000000000000_00 +0000A07E_40E40FC000000000_00 +FFFFA59F_C0D6984000000000_00 +C0000000_C1D0000000000000_00 +E0007FDE_C1BFFF8022000000_00 +FFF8343E_C11F2F0800000000_00 +E0000000_C1C0000000000000_00 +0000FF7C_40EFEF8000000000_00 +FFFFFFF7_C022000000000000_00 +F0000000_C1B0000000000000_00 +BDFFFFFC_C1D0800001000000_00 +FFFFE3C1_C0BC3F0000000000_00 +F8000000_C1A0000000000000_00 +28003FFE_41C4001FFF000000_00 +00000000_0000000000000000_00 +FC000000_C190000000000000_00 +00EEFFFF_416DDFFFE0000000_00 +00003EB0_40CF580000000000_00 +FE000000_C180000000000000_00 +00000F7D_40AEFA0000000000_00 +FFFFFF0F_C06E200000000000_00 +FF000000_C170000000000000_00 +0000406D_40D01B4000000000_00 +0000001A_403A000000000000_00 +FF800000_C160000000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000000A_4024000000000000_00 +FFC00000_C150000000000000_00 +FFFF007C_C0EFF08000000000_00 +0000009B_4063600000000000_00 +FFE00000_C140000000000000_00 +00E00FFF_416C01FFE0000000_00 +00000006_4018000000000000_00 +FFF00000_C130000000000000_00 +00200FFC_414007FE00000000_00 +00000714_409C500000000000_00 +FFF80000_C120000000000000_00 +F800040E_C19FFFEFC8000000_00 +00000013_4033000000000000_00 +FFFC0000_C110000000000000_00 +F83BFFFF_C19F100004000000_00 +FFF3F584_C12814F800000000_00 +FFFE0000_C100000000000000_00 +F6FFFBFF_C1A2000802000000_00 +FFFFFFF0_C030000000000000_00 +FFFF0000_C0F0000000000000_00 +80003FFD_C1DFFFF000C00000_00 +FFFFFFAD_C054C00000000000_00 +FFFF8000_C0E0000000000000_00 +004001FD_4150007F40000000_00 +000D734E_412AE69C00000000_00 +FFFFC000_C0D0000000000000_00 +006003FE_415800FF80000000_00 +FF9DBAA8_C158915600000000_00 +FFFFE000_C0C0000000000000_00 +000403EE_41100FB800000000_00 +00734668_415CD19A00000000_00 +FFFFF000_C0B0000000000000_00 +01200002_4172000020000000_00 +FF8874A5_C15DE2D6C0000000_00 +FFFFF800_C0A0000000000000_00 +00060001_4118000400000000_00 +FFFFFFF8_C020000000000000_00 +FFFFFC00_C090000000000000_00 +001FFEDD_413FFEDD00000000_00 +FFFC56DF_C10D490800000000_00 +FFFFFE00_C080000000000000_00 +EFFFEFFD_C1B0001003000000_00 +FECF5EC6_C1730A13A0000000_00 +FFFFFF00_C070000000000000_00 +1FF00002_41BFF00002000000_00 +F6DB786B_C1A2490F2A000000_00 +FFFFFF80_C060000000000000_00 +F0000FBE_C1AFFFE084000000_00 +00000009_4022000000000000_00 +FFFFFFC0_C050000000000000_00 +0010801F_4130801F00000000_00 +0001F238_40FF238000000000_00 +FFFFFFE0_C040000000000000_00 +F8000047_C19FFFFEE4000000_00 +0002133C_410099E000000000_00 +FFFFFFF0_C030000000000000_00 +003C001F_414E000F80000000_00 +000001F1_407F100000000000_00 +FFFFFFF8_C020000000000000_00 +FFDFBFFF_C140200080000000_00 +FF5E507F_C16435F020000000_00 +FFFFFFFC_C010000000000000_00 +037FFFDE_418BFFFEF0000000_00 +FFFD7C6F_C1041C8800000000_00 +FFFFFFFE_C000000000000000_00 +000000FD_406FA00000000000_00 +FFFFF42A_C0A7AC0000000000_00 +FFFFFFFF_BFF0000000000000_00 +021FFF7D_4180FFFBE8000000_00 +0000000A_4024000000000000_00 +FFFFFFFD_C008000000000000_00 +4010FFFF_41D0043FFFC00000_00 +FFFFFFD3_C046800000000000_00 +FFFFFFFB_C014000000000000_00 +FFFF800B_C0DFFD4000000000_00 +000000B8_4067000000000000_00 +FFFFFFF7_C022000000000000_00 +FF800803_C15FFDFF40000000_00 +FFFFFFFE_C000000000000000_00 +FFFFFFEF_C031000000000000_00 +00803FFB_416007FF60000000_00 +00000308_4088400000000000_00 +FFFFFFDF_C040800000000000_00 +2107FFFE_41C083FFFF000000_00 +FFE15D4F_C13EA2B100000000_00 +FFFFFFBF_C050400000000000_00 +400087FD_41D00021FF400000_00 +0000000F_402E000000000000_00 +FFFFFF7F_C060200000000000_00 +FDFC007E_C1801FFC10000000_00 +00000006_4018000000000000_00 +FFFFFEFF_C070100000000000_00 +FFF80100_C11FFC0000000000_00 +FFFFFE99_C076700000000000_00 +FFFFFDFF_C080080000000000_00 +03000002_4188000010000000_00 +FFF716EA_C121D22C00000000_00 +FFFFFBFF_C090040000000000_00 +C7FDFFFF_C1CC010000800000_00 +FFFFE327_C0BCD90000000000_00 +FFFFF7FF_C0A0020000000000_00 +0103DFFE_41703DFFE0000000_00 +07661FD8_419D987F60000000_00 +FFFFEFFF_C0B0010000000000_00 +83FFFFFE_C1DF000000800000_00 +FCD956DB_C189354928000000_00 +FFFFDFFF_C0C0008000000000_00 +FF2001FD_C16BFFC060000000_00 +E4D35BBF_C1BB2CA441000000_00 +FFFFBFFF_C0D0004000000000_00 +DFEFEFFE_C1C0080801000000_00 +05DA4300_4197690C00000000_00 +FFFF7FFF_C0E0002000000000_00 +40001040_41D0000410000000_00 +812EDF40_C1DFB44830000000_00 +FFFEFFFF_C0F0001000000000_00 +FFFFC007_C0CFFC8000000000_00 +00B6FCC9_4166DF9920000000_00 +FFFDFFFF_C100000800000000_00 +000007FE_409FF80000000000_00 +FC3DE950_C18E10B580000000_00 +FFFBFFFF_C110000400000000_00 +7FFFFE03_41DFFFFF80C00000_00 +FEB02B59_C174FD4A70000000_00 +FFF7FFFF_C120000200000000_00 +10FF7FFF_41B0FF7FFF000000_00 +00008D5E_40E1ABC000000000_00 +FFEFFFFF_C130000100000000_00 +FFFF007E_C0EFF04000000000_00 +001C2108_413C210800000000_00 +FFDFFFFF_C140000080000000_00 +00FFC001_416FF80020000000_00 +F01C6B36_C1AFC72994000000_00 +FFBFFFFF_C150000040000000_00 +FFFF7FFF_C0E0002000000000_00 +FFFFD055_C0C7D58000000000_00 +FF7FFFFF_C160000020000000_00 +027BFFFE_4183DFFFF0000000_00 +FF3090D0_C169EDE600000000_00 +FEFFFFFF_C170000010000000_00 +00082040_4120408000000000_00 +0000006E_405B800000000000_00 +FDFFFFFF_C180000008000000_00 +FDFFFF87_C1800003C8000000_00 +04C3764D_41930DD934000000_00 +FBFFFFFF_C190000004000000_00 +0006007E_411801F800000000_00 +000001EF_407EF00000000000_00 +F7FFFFFF_C1A0000002000000_00 +FFBF7FFE_C150200080000000_00 +FF1C4E5A_C16C7634C0000000_00 +EFFFFFFF_C1B0000001000000_00 +FFF97FFD_C11A000C00000000_00 +000001D1_407D100000000000_00 +DFFFFFFF_C1C0000000800000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00136721_4133672100000000_00 +BFFFFFFF_C1D0000000400000_00 +00004BFF_40D2FFC000000000_00 +00000544_4095100000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +FFF8BD5E_C11D0A8800000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_C1501FFF40000000_00 +FFFE45D2_C0FBA2E000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_C082080000000000_00 +FFFFF189_C0ACEE0000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_C0F9002000000000_00 +FC8672A0_C18BCC6B00000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +FFFCCA70_C109AC8000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +FFFF48E7_C0E6E32000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_C1A0040024000000_00 +00000010_4030000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_C0EFC06000000000_00 +0000FAEF_40EF5DE000000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000000F5_406EA00000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_C13F804000000000_00 +001AFFFB_413AFFFB00000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +FF4613B2_C1673D89C0000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_C1AFFFF404000000_00 +00036402_410B201000000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_C087F00000000000_00 +FFFF41C6_C0E7C74000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +FFFFFFFB_C014000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_C178020020000000_00 +FFFFFFFD_C008000000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_C1C2200001000000_00 +00000404_4090100000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_C0CFF40000000000_00 +00002853_40C4298000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +FFFFF124_C0ADB80000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_C0B0420000000000_00 +FFFB9AD8_C11194A000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_C1C0000101000000_00 +FFFFFD95_C083580000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_C180000008000000_00 +FFFFFFD0_C048000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +010EC496_4170EC4960000000_00 +0000007F_405FC00000000000_00 +B8007FFF_C1D1FFE000400000_00 +00000012_4032000000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +FFFFFFEF_C031000000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_C160001FC0000000_00 +FFFFE2CE_C0BD320000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +FFFFFE44_C07BC00000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +000038E7_40CC738000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_rd.tv b/wally-pipelined/testbench/fp/i64_f32_rd.tv index 9e003f1c2..acfef2bdd 100644 --- a/wally-pipelined/testbench/fp/i64_f32_rd.tv +++ b/wally-pipelined/testbench/fp/i64_f32_rd.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 5CFFFFBF_01 -0000000032CC8B7A 4E4B322D_01 -0000000000000000 00000000_00 -FFFFFFFFC0003FFE CE7FFF01_01 -032C857F319EDE38 5C4B215F_01 -0000000000000001 3F800000_00 -FFFFFBFFFFF8003E D4800001_01 -00394C79B6D3007B 5A6531E6_01 -0000000000000002 40000000_00 -FBFFFFF0000001FF DC800002_01 -0000000001AE458D 4BD722C6_01 -0000000000000004 40800000_00 -00040008000007FE 58800100_01 -F9EB456140D88764 DCC29754_01 -0000000000000008 41000000_00 -FFFFE400FFFFFFFE D5DFF801_01 -07DE834A248EDF36 5CFBD069_01 -0000000000000010 41800000_00 -00000003FF001FFF 507FC007_01 -FFFFFFFFFFE385E2 C9E3D0F0_00 -0000000000000020 42000000_00 -F0041FFFFFFFFFFF DD7FBE01_01 -000000059EB1FD45 50B3D63F_01 -0000000000000040 42800000_00 -FFFFFFFFFFFCFFF9 C84001C0_00 -FFFFFFFFFFFEDDFE C7910100_00 -0000000000000080 43000000_00 -000000000003FF00 487FC000_00 -00000000C89FF56B 4F489FF5_01 -0000000000000100 43800000_00 -000FFFFF7FDFFFFF 597FFFF7_01 -1B5E4F0BE0DEBFF0 5DDAF278_01 -0000000000000200 44000000_00 -FFFDF803FFFFFFFF D801FF01_01 -FFFFFFFFFFF4766B C9389950_00 -0000000000000400 44800000_00 -0000080100000FFE 55001000_01 -000000000000000C 41400000_00 -0000000000000800 45000000_00 -0048000000100000 5A900000_01 -FFE662A109109D0A D9CCEAF8_01 -0000000000001000 45800000_00 -C000000037FFFFFE DE800000_01 -FFFFFFFFFFFFFFE4 C1E00000_00 -0000000000002000 46000000_00 -F801000000100000 DCFFE000_01 -FE114B79075F70EE DBF75A44_01 -0000000000004000 46800000_00 -100000000001003E 5D800000_01 -00000000000003AC 446B0000_00 -0000000000008000 47000000_00 -200000FFFFFFF800 5E000003_01 -00000044A3A3DBE5 52894747_01 -0000000000010000 47800000_00 -FFE0003EFFFFFFFF D9FFFE09_01 -FFFFFFFFFFFF1A91 C7656F00_00 -0000000000020000 48000000_00 -FFFFF7C3FFFFFFFD D503C001_01 -0000000000003309 464C2400_00 -0000000000040000 48800000_00 -000083FFF7FFFFFE 5703FFF7_01 -FFFFFFFFFFFFFF58 C3280000_00 -0000000000080000 49000000_00 -FFFFFFDE01FFFFFE D207F801_01 -0000000000002980 46260000_00 -0000000000100000 49800000_00 -00000000FFF07FFF 4F7FF07F_01 -000000000000005D 42BA0000_00 -0000000000200000 4A000000_00 -000020FFDFFFFFFF 5603FF7F_01 -FFFC8C23DA2CEAD8 D85CF70A_01 -0000000000400000 4A800000_00 -E0000000003FFFDF DE000000_01 -FFFFFDE3C1DEC43C D4070F89_01 -0000000000800000 4B000000_00 -FFFF00000BFFFFFD D77FFFF5_01 -000000000030FFBE 4A43FEF8_00 -0000000001000000 4B800000_00 -FFFE000007FFEFFD D7FFFFFD_01 -FFFFFFFFEFDEED86 CD810894_01 -0000000002000000 4C000000_00 -F3FFFFFFFFBFFFFE DD400001_01 -000000001DA3FF45 4DED1FFA_01 -0000000004000000 4C800000_00 -FFFFFFFF00010007 CF7FFF00_01 -FFFFFFFE9B1BCB54 CFB2721B_01 -0000000008000000 4D000000_00 -00004000004001FE 56800000_01 -F27DD19DE6563714 DD5822E7_01 -0000000010000000 4D800000_00 -FFC00000004007FE DA800000_01 -000000000001A359 47D1AC80_00 -0000000020000000 4E000000_00 -0000000003C000FE 4C70003F_01 -FFFFFFFFFE62EC20 CBCE89F0_00 -0000000040000000 4E800000_00 -000000003FFFFFFD 4E7FFFFF_01 -000000000000285F 46217C00_00 -0000000080000000 4F000000_00 -FFFFFFFFBFFFF00F CE800020_01 -FFFFF836F99DBAA8 D4F920CD_01 -0000000100000000 4F800000_00 -00000020003FFEFE 520000FF_01 -0033466832042D47 5A4D19A0_01 -0000000200000000 50000000_00 -FFFFFFFFFFFFF887 C4EF2000_00 -00000000003829C8 4A60A720_00 -0000000400000000 50800000_00 -00000FFFFFFF7DFD 557FFFFF_01 -0000000FB77C672B 517B77C6_01 -0000000800000000 51000000_00 -08003FFDFFFFFFFE 5D0003FF_01 -0000000000001B78 45DBC000_00 -0000001000000000 51800000_00 -FF7FFFFFFFEFDFFF DB000001_01 -0000000000000071 42E20000_00 -0000002000000000 52000000_00 -000013FFFFFFFDFF 559FFFFF_01 -FFFFFFFFFFFFFF86 C2F40000_00 -0000004000000000 52800000_00 -0800000000040800 5D000000_01 -FFF8A60D9E19F17E D8EB3E4D_01 -0000008000000000 53000000_00 -000077FFF0000000 56EFFFE0_00 -FFFFFFFFF7506DBA CD0AF925_01 -0000010000000000 53800000_00 -FFFFFFFFFFFEFBF7 C7820480_00 -FFFFFFFFFEA42AC9 CBADEA9C_01 -0000020000000000 54000000_00 -0000107FFFFFDFFD 5583FFFF_01 -FFE7AA3F2BDACC89 D9C2AE07_01 -0000040000000000 54800000_00 -FFF8040000040000 D8FF8000_01 -FFFFFFFFFFFFFFFD C0400000_00 -0000080000000000 55000000_00 -FFFF80000800001F D6FFFFF0_01 -FFFDF681DECDADC9 D8025F89_01 -0000100000000000 55800000_00 -FFFFFEFFFFE0007F D3800010_01 -FFFFFFFFFFFFCFBE C6410800_00 -0000200000000000 56000000_00 -0000000901FFFFFD 51101FFF_01 -FEC01FECA24DE1B0 DB9FF00A_01 -0000400000000000 56800000_00 -F7FFFFFFDFFF7FFF DD000001_01 -F858A66761669936 DCF4EB34_01 -0000800000000000 57000000_00 -FFFEFF800000003E D7804000_01 -F716EA43FAC45C97 DD0E915C_01 -0001000000000000 57800000_00 -FFFFFFFFFFFFFFC6 C2680000_00 -0024D70EC7661FD8 5A135C3B_01 -0002000000000000 58000000_00 -C07FFFFFFFFFFFFE DE7E0001_01 -FFD956DBD0AEE817 DA1AA491_01 -0004000000000000 58800000_00 -020003EFFFFFFFFE 5C0000FB_01 -FFFFFFFFFFFF4300 C73D0000_00 -0008000000000000 59000000_00 -4000000004002000 5E800000_01 -C12EDF40F41F6021 DE7B4483_01 -0010000000000000 59800000_00 -FF9000000000001D DAE00000_01 -FFFFFFF83DE950F6 D0F842D6_01 -0020000000000000 5A000000_00 -800003FFFFFC0000 DEFFFFF9_01 -FE2B59CB3A604D69 DBEA531B_01 -0040000000000000 5A800000_00 -7FFFFFFDFFFFBFFF 5EFFFFFF_01 -000000A37C210862 53237C21_01 -0080000000000000 5B000000_00 -0002000002000002 58000000_01 -FFFFB65CD8617789 D6934650_01 -0100000000000000 5B800000_00 -00001BFFFFFFBFFE 55DFFFFF_01 -FFFFFFFFFFFFF01D C57E3000_00 -0200000000000000 5C000000_00 -1000008000003FFF 5D800004_01 -000000000D098D19 4D5098D1_01 -0400000000000000 5C800000_00 -03FFFFFFFFFFF5FF 5C7FFFFF_01 -000006B3BD2C7BEF 54D677A5_01 -0800000000000000 5D000000_00 -00003FFFBFFFFFFE 567FFEFF_01 -FFFF4E5ADDDAA4A8 D731A523_01 -1000000000000000 5D800000_00 -001FFFC000000FFD 59FFFE00_01 -FFFFFFFFFFFFFF21 C35F0000_00 -2000000000000000 5E000000_00 -0000000041DFFFFF 4E83BFFF_01 -FFFFFFFFFC648262 CC66DF68_01 -4000000000000000 5E800000_00 -C0001FFFFFFFFFFB DE7FFF81_01 -FFFFFF7353AC45D2 D30CAC54_01 -8000000000000000 DF000000_00 -FFFFFFFFFFE7EFFF C9C08008_00 -0000000000A1202D 4B21202D_00 -C000000000000000 DE800000_00 -FFFFFFFFFFFF5F7F C7208100_00 -000000000040CA70 4A8194E0_00 -E000000000000000 DE000000_00 -0000200201FFFFFE 56000807_01 -00000003B55D87D4 506D5761_01 -F000000000000000 DD800000_00 -FF80000DFFFFFFFF DAFFFFE5_01 -000000010510FAEF 4F82887D_01 -F800000000000000 DD000000_00 -0003FFF00000000F 587FFC00_01 -000000000000724A 46E49400_00 -FC00000000000000 DC800000_00 -FFFFFFDF80000002 D2020000_01 -0000000000000064 42C80000_00 -FE00000000000000 DC000000_00 -FEFFFFFFFFF800FE DB800001_01 -FFFFFFC2C6222702 D274E778_01 -FF00000000000000 DB800000_00 -0000000408000002 50810000_01 -000000E96DF1CB41 53696DF1_01 -FF80000000000000 DB000000_00 -007FFFFFFFFFF9FE 5AFFFFFF_01 -F727F174DEE7DC85 DD0D80E9_01 -FFC0000000000000 DA800000_00 -8000000003FFFEFE DF000000_01 -FFFFFFFFFFF0BD5B C9742A50_00 -FFE0000000000000 DA000000_00 -0BEFFFFFFFFFFFFF 5D3EFFFF_01 -000000000002790C 481E4300_00 -FFF0000000000000 D9800000_00 -FFFFFFFFFFEFFBFA C9802030_00 -000000169E75DF01 51B4F3AE_01 -FFF8000000000000 D9000000_00 -00000007FEFFDFFF 50FFDFFB_01 -000000000000000E 41600000_00 -FFFC000000000000 D8800000_00 -0003FFFE0007FFFE 587FFF80_01 -FFFFFFFFFFF28622 C9579DE0_00 -FFFE000000000000 D8000000_00 -FFFFFF7FFFFDF7FF D3000003_01 -00072F0EC496FE21 58E5E1D8_01 -FFFF000000000000 D7800000_00 -DFBFFFFFFFFFFFFE DE010001_01 -0000000000FC1FCA 4B7C1FCA_00 -FFFF800000000000 D7000000_00 -00000FFF800FFFFE 557FF800_01 -FFFF5194E4A9C2CE D72E6B1C_01 -FFFFC00000000000 D6800000_00 -00000002100007FD 50040001_01 -FFFFFFFFFFC2D8FE CA749C08_00 -FFFFE00000000000 D6000000_00 -000000000007FF6E 48FFEDC0_00 -000000000001766E 47BB3700_00 -FFFFF00000000000 D5800000_00 -0040000400000002 5A800008_01 -0000000000007841 46F08200_00 -FFFFF80000000000 D5000000_00 -3DFFFFFFFFFFFF7E 5E77FFFF_01 -FFFFFFE549E17E30 D1D5B0F5_01 -FFFFFC0000000000 D4800000_00 -FFFFFFFFFFFFFEE1 C38F8000_00 -FFFFFFFFFFFFFFE7 C1C80000_00 -FFFFFE0000000000 D4000000_00 -000000000EFFFFDF 4D6FFFFD_01 -FFFFFFFFFFFFFF73 C30D0000_00 -FFFFFF0000000000 D3800000_00 -FD00000008000000 DC400000_01 -000000000001DBB1 47EDD880_00 -FFFFFF8000000000 D3000000_00 -FFFFFFFFFFF8007F C8FFF020_00 -FFFFFFFEFD10A515 CF8177AE_01 -FFFFFFC000000000 D2800000_00 -FFEFFFFFFFFFFFFE D9800001_01 -FAB02984F6283B6C DCA9FAD0_01 -FFFFFFE000000000 D2000000_00 -FFFFFFBC000001FE D2880000_01 -FEB087C6B9FE7FE0 DBA7BC1D_01 -FFFFFFF000000000 D1800000_00 -FFF80001000007FE D8FFFFE0_01 -00F2762EA6837956 5B72762E_01 -FFFFFFF800000000 D1000000_00 -FFF7E0FFFFFFFFFE D901F001_01 -00002E1175484626 563845D5_01 -FFFFFFFC00000000 D0800000_00 -0000200020000FFE 56000080_01 -000000000000068F 44D1E000_00 -FFFFFFFE00000000 D0000000_00 -021FFFFFFFFBFFFF 5C07FFFF_01 -FFFFFFFFFFFFFFF9 C0E00000_00 -FFFFFFFF00000000 CF800000_00 -FFFFFFD0000FFFFD D23FFFC1_01 -000000BDF6658B83 533DF665_01 -FFFFFFFF80000000 CF000000_00 -1000001FFDFFFFFF 5D800000_01 -0000000000003B5B 466D6C00_00 -FFFFFFFFC0000000 CE800000_00 -FFFFFFBFFE0FFFFF D28003E1_01 -FFFFFFFFFFFFFFF0 C1800000_00 -FFFFFFFFE0000000 CE000000_00 -FFFFFFFBF00007FF D0820000_01 -01E986274F48EAAD 5BF4C313_01 -FFFFFFFFF0000000 CD800000_00 -1FFFFFFDFFFFFF7F 5DFFFFFF_01 -FFFFFFFFFFFFCB5A C6529800_00 -FFFFFFFFF8000000 CD000000_00 -7FF000000000FFFF 5EFFE000_01 -00000003C2717FC3 50709C5F_01 -FFFFFFFFFC000000 CC800000_00 -FFFFFFE00008001F D1FFFFC0_01 -FFFFFFFFFFEFABDA C982A130_00 -FFFFFFFFFE000000 CC000000_00 -0200000000000002 5C000000_01 -FFFFFFFFF8FDA53F CCE04B59_01 -FFFFFFFFFF000000 CB800000_00 -F6000003FFFFFFFE DD200000_01 -FFFFFFFFFFFFFFD0 C2400000_00 -FFFFFFFFFF800000 CB000000_00 -FFFFFFFFFFBFFF7E CA800104_00 -00000000EE0FEA62 4F6E0FEA_01 -FFFFFFFFFFC00000 CA800000_00 -0000007FFF9FFFFD 52FFFF3F_01 -00000037F35EDC1D 525FCD7B_01 -FFFFFFFFFFE00000 CA000000_00 -FFFFFFF7FDFFFF7D D1002001_01 -00000000000001AD 43D68000_00 -FFFFFFFFFFF00000 C9800000_00 -FFFFFF0000100020 D37FFFF0_01 -27F167FBC7FC5F9A 5E1FC59F_01 -FFFFFFFFFFF80000 C9000000_00 -003FFFFFFFFC0001 5A7FFFFF_01 -000E48F9F4EBD30E 59648F9F_01 -FFFFFFFFFFFC0000 C8800000_00 -DFFFFFFFFFFBFFFE DE000001_01 -FC91C23EE8C9424F DC5B8F71_01 -FFFFFFFFFFFE0000 C8000000_00 -F7DFFBFFFFFFFFFE DD020041_01 -000000002CAE080C 4E32B820_01 -FFFFFFFFFFFF0000 C7800000_00 -FFFFC00010000020 D67FFFC0_01 -04D921F917B20E40 5C9B243F_01 -FFFFFFFFFFFF8000 C7000000_00 -F8000FFFFFFFFFFD DCFFFE01_01 -FFF17C566BC7D811 D9683A9A_01 -FFFFFFFFFFFFC000 C6800000_00 -00000000000000FE 437E0000_00 -FFF82AC14930D386 D8FAA7D7_01 -FFFFFFFFFFFFE000 C6000000_00 -00000000000003FC 447F0000_00 -000E62EC60E119FC 59662EC6_01 -FFFFFFFFFFFFF000 C5800000_00 -FFFFEFF7FF7FFFFE D5804005_01 -0E2B1ECF210EEDC5 5D62B1EC_01 -FFFFFFFFFFFFF800 C5000000_00 -00000000007FFF1F 4AFFFE3E_00 -FFFFFE534F5676F7 D3D65855_01 -FFFFFFFFFFFFFC00 C4800000_00 -0000001004FFFFFD 518027FF_01 -0000035C939669F1 545724E5_01 -FFFFFFFFFFFFFE00 C4000000_00 -1FFFFFFFFFFFFDFD 5DFFFFFF_01 -FFFFFFFFFFFFFF91 C2DE0000_00 -FFFFFFFFFFFFFF00 C3800000_00 -01FFFFFFFBFFEFFE 5BFFFFFF_01 -000000000000016E 43B70000_00 -FFFFFFFFFFFFFF80 C3000000_00 -FFF7FFFFFFFFF7FD D9000001_01 -FFFFF8E2BCFAC553 D4E3A861_01 -FFFFFFFFFFFFFFC0 C2800000_00 -FFFFFBFFFFFE0FFE D4800001_01 -00000001A4E704BF 4FD27382_01 -FFFFFFFFFFFFFFE0 C2000000_00 -1400007FFFFFFFFD 5DA00003_01 -FFFFFFFC93B187B4 D05B139F_01 -FFFFFFFFFFFFFFF0 C1800000_00 -40000000007FFFFD 5E800000_01 -000000000067D468 4ACFA8D0_00 -FFFFFFFFFFFFFFF8 C1000000_00 -007FFEFFFFFBFFFE 5AFFFDFF_01 -FFFFFFE26CEC79F8 D1EC989D_01 -FFFFFFFFFFFFFFFC C0800000_00 -00FFFFFF000000FF 5B7FFFFF_01 -FFFFFFFFE0D3983A CDF9633F_01 -FFFFFFFFFFFFFFFE C0000000_00 -00007FFFBFFF7FFE 56FFFF7F_01 -FFFFFFFDF4A7088A D002D63E_01 -FFFFFFFFFFFFFFFF BF800000_00 -000008000000027E 55000000_01 -000000000000F4E8 4774E800_00 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFF83FFDF CAF80042_00 -00000E11407887B2 55611407_01 -FFFFFFFFFFFFFFFB C0A00000_00 -04000003FFFFFFF6 5C800000_01 -0000000000000513 44A26000_00 -FFFFFFFFFFFFFFF7 C1100000_00 -BFFC00000000003E DE800800_01 -00000008D7BBB75B 510D7BBB_01 -FFFFFFFFFFFFFFEF C1880000_00 -000FFFFBFFFC0000 597FFFBF_01 -FFFFFFFFFFCD5A23 CA4A9774_00 -FFFFFFFFFFFFFFDF C2040000_00 -FFBFDFFFBFFFFFFF DA804001_01 -000000000000007F 42FE0000_00 -FFFFFFFFFFFFFFBF C2820000_00 -00000007FF800003 50FFF000_01 -000000000002BB02 482EC080_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEE7FF C78C0080_00 -00264B2B9BAD0DA2 5A192CAE_01 -FFFFFFFFFFFFFEFF C3808000_00 -0000000000100803 49804018_00 -FF9B1DCB9F857D5E DAC9C469_01 -FFFFFFFFFFFFFDFF C4004000_00 -FFFFFFBFFFFFEFEE D2800001_01 -F6FD7542899C1C6F DD1028AC_01 -FFFFFFFFFFFFFBFF C4802000_00 -FF800000004001FF DB000000_01 -0000000002BE4932 4C2F924C_01 -FFFFFFFFFFFFF7FF C5001000_00 -00001004000FFFFE 55802000_01 -FFFFFF9DAA0123E0 D2C4ABFE_01 -FFFFFFFFFFFFEFFF C5800800_00 -00000001FDFFFDFE 4FFEFFFE_01 -FFFC1C8703B1DCB0 D878DE40_01 -FFFFFFFFFFFFDFFF C6000400_00 -FE0FE00000000000 DBF81000_00 -0779ED944A4E2779 5CEF3DB2_01 -FFFFFFFFFFFFBFFF C6800200_00 -FBFFFE0400000000 DC800040_01 -0000010127E03666 538093F0_01 -FFFFFFFFFFFF7FFF C7000100_00 -FFFFF0200000FFFE D57E0000_01 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEFFFF C7800080_00 -FFEFFE0000080000 D9801000_01 -FFFFFFFFFD3354EA CC332AC6_01 -FFFFFFFFFFFDFFFF C8000040_00 -003FF0000003FFFE 5A7FC000_01 -0000006375B23F7B 52C6EB64_01 -FFFFFFFFFFFBFFFF C8800020_00 -000407FFFFFFFFF6 5880FFFF_01 -0000000092117F38 4F12117F_01 -FFFFFFFFFFF7FFFF C9000010_00 -FFFFFFFFFFFF7FFF C7000100_00 -00000000000008BE 450BE000_00 -FFFFFFFFFFEFFFFF C9800008_00 -004000020FFFFFFF 5A800004_01 -FFFFB84C2D8BC9CB D68F67A5_01 -FFFFFFFFFFDFFFFF CA000004_00 -00FFFFFFFFFFFFFD 5B7FFFFF_01 -00000023C2C6F284 520F0B1B_01 -FFFFFFFFFFBFFFFF CA800002_00 -FFFDDFFFFFFFFFFD D8080001_01 -00000000746356C4 4EE8C6AD_01 -FFFFFFFFFF7FFFFF CB000001_00 -010000000000BFFF 5B800000_01 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFEFFFFFF CB800001_01 -FFFFBF7FFBFFFFFE D6810009_01 -00000006386CE889 50C70D9D_01 -FFFFFFFFFDFFFFFF CC000001_01 -F00000F7FFFFFFFF DD7FFFF1_01 -FFFDFC53090C46A4 D800EB3E_01 -FFFFFFFFFBFFFFFF CC800001_01 -0000000000800047 4B000047_00 -FFFFFFFFD693872E CE25B1E4_01 -FFFFFFFFF7FFFFFF CD000001_01 -000000007FBFFBFF 4EFF7FF7_01 -00000026A7845E35 521A9E11_01 -FFFFFFFFEFFFFFFF CD800001_01 -FFFFFFDFFFFFFBFD D2000001_01 -000000001433D14C 4DA19E8A_01 -FFFFFFFFDFFFFFFF CE000001_01 -0001FFFFFFE0000E 57FFFFFF_01 -F0F23E8068D3D84A DD70DC18_01 -FFFFFFFFBFFFFFFF CE800001_01 -F7FFBFFFFFFFBFFF DD000401_01 -FFFFBD29B7459087 D685AC92_01 -FFFFFFFF7FFFFFFF CF000001_01 -FFFFFFF8FFFFBFFF D0E00009_01 -FFFFFFFFFFEDDC06 C9911FD0_00 -FFFFFFFEFFFFFFFF CF800001_01 -FFFFFFF80001FFFF D0FFFFC1_01 -0000000000002FF9 463FE400_00 -FFFFFFFDFFFFFFFF D0000001_01 -004000040000FFFF 5A800008_01 -FFFFFFFFFFFFFFF1 C1700000_00 -FFFFFFFBFFFFFFFF D0800001_01 -C0000000007FFFFA DE800000_01 -FFFFFFFFFE053E2B CBFD60EB_01 -FFFFFFF7FFFFFFFF D1000001_01 -7FFE000007FFFFFF 5EFFFC00_01 -000000000000000D 41500000_00 -FFFFFFEFFFFFFFFF D1800001_01 -F80000000001007E DD000000_01 -FFFFED48424AD9D6 D595BDEE_01 -FFFFFFDFFFFFFFFF D2000001_01 -FFFFFE0001FEFFFF D3FFFF01_01 -000000000000013B 439D8000_00 -FFFFFFBFFFFFFFFF D2800001_01 -0007FBFFFFFDFFFE 58FF7FFF_01 -4A16BD4128090C83 5E942D7A_01 -FFFFFF7FFFFFFFFF D3000001_01 -00FFF7FFFF7FFFFE 5B7FF7FF_01 -0000000000000006 40C00000_00 -FFFFFEFFFFFFFFFF D3800001_01 -FBFFFFBFFFBFFFFF DC800009_01 -00000000000001BA 43DD0000_00 -FFFFFDFFFFFFFFFF D4000001_01 -0000000040000082 4E800001_01 -FF07A2BF5B689F89 DB785D41_01 -FFFFFBFFFFFFFFFF D4800001_01 -0000001FF8000008 51FFC000_01 -F87CAA7DE672DE8B DCF06AB1_01 -FFFFF7FFFFFFFFFF D5000001_01 -07FFF80000000002 5CFFFF00_01 -0000000010A1E5B8 4D850F2D_01 -FFFFEFFFFFFFFFFF D5800001_01 -F7FFFFE00007FFFF DD000002_01 -FFFFFFFFFFF6ADFC C9152040_00 -FFFFDFFFFFFFFFFF D6000001_01 -FFFFFF03FFFFFFC0 D37C0001_01 -EA579475948F0032 DDAD435D_01 -FFFFBFFFFFFFFFFF D6800001_01 -FC00000000003FF6 DC800000_01 -002E677AC313BF60 5A399DEB_01 -FFFF7FFFFFFFFFFF D7000001_01 -02000007FF7FFFFF 5C000001_01 -0000000E999639F1 51699963_01 -FFFEFFFFFFFFFFFF D7800001_01 -FFFF83FFFFFFFFBE D6F80001_01 -000000000001537D 47A9BE80_00 -FFFDFFFFFFFFFFFF D8000001_01 -EFFFFFC00000003D DD800002_01 -FFFFFFF21FEDFD35 D15E0121_01 -FFFBFFFFFFFFFFFF D8800001_01 -FFFFFFF0000007FE D1800000_01 -FFFFFFFFFFDE0839 CA07DF1C_00 -FFF7FFFFFFFFFFFF D9000001_01 -0000007FFFE000FF 52FFFFC0_01 -FFFFFFFF79F30F48 CF060CF1_01 -FFEFFFFFFFFFFFFF D9800001_01 -FFFFFC13FFFFFFFD D47B0001_01 -0000000000001B85 45DC2800_00 -FFDFFFFFFFFFFFFF DA000001_01 -000008000007FFFE 55000000_01 -12DB4409E5AE87E6 5D96DA20_01 -FFBFFFFFFFFFFFFF DA800001_01 -FFFFFFFFFFF7BFEE C9040120_00 -FFFFFFFFFFFFFFFD C0400000_00 -FF7FFFFFFFFFFFFF DB000001_01 -000000001040FFFE 4D8207FF_01 -00000909A09C13D3 55109A09_01 -FEFFFFFFFFFFFFFF DB800001_01 -FFFFFF01FFFFFF7F D37E0001_01 -FFFFFF72E7D2575D D30D182E_01 -FDFFFFFFFFFFFFFF DC000001_01 -FFFFFFFFFFFEFFDB C7801280_00 -0000000000000017 41B80000_00 -FBFFFFFFFFFFFFFF DC800001_01 -100000001FFFFFF6 5D800000_01 -000000114B12EF51 518A5897_01 -F7FFFFFFFFFFFFFF DD000001_01 -0407FFFFFFFFFEFF 5C80FFFF_01 -FFFFFF769F3A5C2C D30960C6_01 -EFFFFFFFFFFFFFFF DD800001_01 -FFFFFFFDF7FFFFFD D0020001_01 -FFFFFFFFFFFFFFF2 C1600000_00 -DFFFFFFFFFFFFFFF DE000001_01 -FFFFFFFFFE0007FF CBFFFC01_01 -000000000000001E 41F00000_00 -BFFFFFFFFFFFFFFF DE800001_01 -FFF800000009FFFF D9000000_01 -0000000000007AA4 46F54800_00 -7FFFFFFFFFFFFFFF 5EFFFFFF_01 -4080000000FFFFFF 5E810000_01 -000000000DE7601D 4D5E7601_01 -3FFFFFFFFFFFFFFF 5E7FFFFF_01 -FFCFFFFFFFBFFFFE DA400001_01 -FFFFFFFFFFFFFFCA C2580000_00 -1FFFFFFFFFFFFFFF 5DFFFFFF_01 -000080400000003F 57004000_01 -00000000001F75A5 49FBAD28_00 -0FFFFFFFFFFFFFFF 5D7FFFFF_01 -FFFFFFEFFFFFCFFE D1800002_01 -FFFFFEE775887420 D38C453C_01 -07FFFFFFFFFFFFFF 5CFFFFFF_01 -00000000000801FE 49001FE0_00 -0000000000213FF1 4A04FFC4_00 -03FFFFFFFFFFFFFF 5C7FFFFF_01 -07FEFFFFFFFFFFEE 5CFFDFFF_01 -0000000000000004 40800000_00 -01FFFFFFFFFFFFFF 5BFFFFFF_01 -0000000820000003 51020000_01 -FFFFFFF9AD105214 D0CA5DF6_01 -00FFFFFFFFFFFFFF 5B7FFFFF_01 -FFFFF00FFFFFFFBE D57F0001_01 -FFFFFFFFFFCC48E7 CA4EDC64_00 -007FFFFFFFFFFFFF 5AFFFFFF_01 -00000FFFEF7FFFFF 557FFEF7_01 -FFFFFFFFFF0BA6CB CB745935_00 -003FFFFFFFFFFFFF 5A7FFFFF_01 -FFFFFF7FBFFFFFBF D3004001_01 -FFFFFFFFFFF24425 C95BBDB0_00 -001FFFFFFFFFFFFF 59FFFFFF_01 -200000001FFBFFFF 5E000000_01 -FFFFFF4E7115EC53 D3318EEB_01 -000FFFFFFFFFFFFF 597FFFFF_01 -FFFFF803FFFFFFBF D4FF8001_01 -FFFFFC2E539ADCFE D4746B1A_01 -0007FFFFFFFFFFFF 58FFFFFF_01 -FFFFFFFFFBFFFFFF CC800001_01 -00000055084732F3 52AA108E_01 -0003FFFFFFFFFFFF 587FFFFF_01 -BFFF7FFFFFFFFE00 DE800101_01 -FFFFFFFFFFFF8543 C6F57A00_00 -0001FFFFFFFFFFFF 57FFFFFF_01 -0000001FFBFFE000 51FFDFFF_00 -FFFFFFFFFFFE491B C7DB7280_00 -0000FFFFFFFFFFFF 577FFFFF_01 -FC00200000001FFE DC7FF800_01 -FFFFF16898822A24 D5697678_01 -00007FFFFFFFFFFF 56FFFFFF_01 -3FFF03FFFFFFFFFE 5E7FFC0F_01 -FFFFFF8FFE18C7BF D2E003CF_01 -00003FFFFFFFFFFF 567FFFFF_01 -FFFFFEFFFEFFFFFD D3800081_01 -00F03620C1266ED9 5B703620_01 -00001FFFFFFFFFFF 55FFFFFF_01 -BF7EFFFFFFFFFFFF DE810201_01 -FFFFFFFFFFFFFFD5 C22C0000_00 -00000FFFFFFFFFFF 557FFFFF_01 -FFFBFFFFF803FFFE D8800001_01 -0000000000068684 48D0D080_00 -000007FFFFFFFFFF 54FFFFFF_01 -DFFFFFE00000001E DE000001_01 -FFFFFFFFFFFFECF5 C5985800_00 -000003FFFFFFFFFF 547FFFFF_01 -FFFF00400000FFFF D77FC000_01 -0000000000000002 40000000_00 -000001FFFFFFFFFF 53FFFFFF_01 -FBFFFFFFFFFFBDFE DC800001_01 -0000000000000BC9 453C9000_00 -000000FFFFFFFFFF 537FFFFF_01 -807FFFFFFFFFDFFE DEFF0001_01 -FFC274E35A70CD76 DA762C73_01 -0000007FFFFFFFFF 52FFFFFF_01 -0FFFFFFFFEFFFFFD 5D7FFFFF_01 -FFFFFFFF00E73AFC CF7F18C6_01 -0000003FFFFFFFFF 527FFFFF_01 -FFC000000001000E DA800000_01 -FFFFFFFFFFFE15E9 C7F50B80_00 -0000001FFFFFFFFF 51FFFFFF_01 -0001FFFFFFFFF3FD 57FFFFFF_01 -0000000000000033 424C0000_00 -0000000FFFFFFFFF 517FFFFF_01 -000000001FFFBFFF 4DFFFDFF_01 -FFFFFFEE6B141E1B D18CA760_01 -00000007FFFFFFFF 50FFFFFF_01 -FFFFFFFFF60007FF CD1FFF81_01 -00000001AB310BA6 4FD59885_01 -00000003FFFFFFFF 507FFFFF_01 -0003FFFFB7FFFFFF 587FFFED_01 -FFFFFFFFFFFFF195 C566B000_00 -00000001FFFFFFFF 4FFFFFFF_01 -FFFFFFFF8000000B CF000000_01 -00000019BA8D5559 51CDD46A_01 -00000000FFFFFFFF 4F7FFFFF_01 -FBFEFFFFFFFFFFF9 DC802001_01 -FFFFFFB6F062822D D2921F3B_01 -000000007FFFFFFF 4EFFFFFF_01 -0001000000000082 57800000_01 -01CEAD9E2FB104A4 5BE756CF_01 -000000003FFFFFFF 4E7FFFFF_01 -000003FFFFFFFF7C 547FFFFF_01 -FFFFFFFFFD681E78 CC25F862_00 -000000001FFFFFFF 4DFFFFFF_01 -00002000400001FF 56000100_01 -0000000000000018 41C00000_00 -000000000FFFFFFF 4D7FFFFF_01 -3FFF80000000003E 5E7FFE00_01 -FFFFFFFFFFFFFF95 C2D60000_00 -0000000007FFFFFF 4CFFFFFF_01 -010000BFFFFFFFFF 5B80005F_01 -0000001697087B19 51B4B843_01 -0000000003FFFFFF 4C7FFFFF_01 -FBFFFFFFFFEEFFFD DC800001_01 -0000000E64BDFC55 51664BDF_01 -0000000001FFFFFF 4BFFFFFF_01 -FC00000001FFFFFE DC800000_01 -FFFED156A62AB849 D79754AD_01 -0000000000FFFFFF 4B7FFFFF_00 -FFFFFFF83FEFFFFD D0F80201_01 -00015354EAE7C259 57A9AA75_01 -00000000007FFFFF 4AFFFFFE_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFF0F4DF3C75 D170B20D_01 -00000000003FFFFF 4A7FFFFC_00 -FFFA000000001FFF D8C00000_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000001FFFFF 49FFFFF8_00 -FFFFFFFFFF7FFE40 CB0001C0_00 -FFFFFFDB5433CB9B D212AF31_01 -00000000000FFFFF 497FFFF0_00 -FFFFFDFFDFFDFFFD D4000801_01 -FFFFFFFFFFDEAE1F CA054784_00 -000000000007FFFF 48FFFFE0_00 -FFFFFFFFF0080006 CD7F8000_01 -FFFFFFFE7735DEC7 CFC46511_01 -000000000003FFFF 487FFFC0_00 -00000001FBFFFFFF 4FFDFFFF_01 -000003757D8B12ED 545D5F62_01 -000000000001FFFF 47FFFF80_00 -FFFFFE07F7FFFFFF D3FC0401_01 -00000A654064E046 55265406_01 -000000000000FFFF 477FFF00_00 -08000000000017FF 5D000000_01 -FFFFFFFFFFFFFFE7 C1C80000_00 -0000000000007FFF 46FFFE00_00 -07FFFFFFFFFFFDF6 5CFFFFFF_01 -FFFFAD78B3D6C3B6 D6A50E99_01 -0000000000003FFF 467FFC00_00 -0000300004000000 56400010_00 -FFFFFFF70B77F34F D10F4881_01 -0000000000001FFF 45FFF800_00 -FFFFFF80006FFFFE D2FFFF21_01 -0000013EB4D67EC8 539F5A6B_01 -0000000000000FFF 457FF000_00 -BFFFDFFFFBFFFFFF DE800041_01 -0005CEAF34EA1DC7 58B9D5E6_01 -00000000000007FF 44FFE000_00 -00004800007FFFFD 56900000_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000000003FF 447FC000_00 -0000000200001000 50000004_00 -00000000000360D0 48583400_00 -00000000000001FF 43FF8000_00 -01003FFFFFFFFFFC 5B801FFF_01 -00C000708FF1BA51 5B400070_01 -00000000000000FF 437F0000_00 -F802000003FFFFFF DCFFC000_01 -0F9E07DCC0BDC061 5D79E07D_01 -000000000000007F 42FE0000_00 -03FF0000000000FF 5C7FC000_01 -FFFFFFE1B9B2A079 D1F2326B_01 -000000000000003F 427C0000_00 -FFF80000000080FF D9000000_01 -00000000001EB5B4 49F5ADA0_00 -000000000000001F 41F80000_00 -000000000077FBFE 4AEFF7FC_00 -00000000005AC607 4AB58C0E_00 -000000000000000F 41700000_00 -FFFFFFFEF80000FF CF840000_01 -000005C5B9D66984 54B8B73A_01 -0000000000000007 40E00000_00 -C001FFFFFFF00000 DE7FF801_01 -00001D06B372AA06 55E8359B_01 -0000000000000003 40400000_00 +07FFFDFFFFFFFF7F_5CFFFFBF_01 +0000000032CC8B7A_4E4B322D_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_CE7FFF01_01 +032C857F319EDE38_5C4B215F_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_D4800001_01 +00394C79B6D3007B_5A6531E6_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_DC800002_01 +0000000001AE458D_4BD722C6_01 +0000000000000004_40800000_00 +00040008000007FE_58800100_01 +F9EB456140D88764_DCC29754_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_D5DFF801_01 +07DE834A248EDF36_5CFBD069_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC007_01 +FFFFFFFFFFE385E2_C9E3D0F0_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_DD7FBE01_01 +000000059EB1FD45_50B3D63F_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_C84001C0_00 +FFFFFFFFFFFEDDFE_C7910100_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000000C89FF56B_4F489FF5_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF7_01 +1B5E4F0BE0DEBFF0_5DDAF278_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_D801FF01_01 +FFFFFFFFFFF4766B_C9389950_00 +0000000000000400_44800000_00 +0000080100000FFE_55001000_01 +000000000000000C_41400000_00 +0000000000000800_45000000_00 +0048000000100000_5A900000_01 +FFE662A109109D0A_D9CCEAF8_01 +0000000000001000_45800000_00 +C000000037FFFFFE_DE800000_01 +FFFFFFFFFFFFFFE4_C1E00000_00 +0000000000002000_46000000_00 +F801000000100000_DCFFE000_01 +FE114B79075F70EE_DBF75A44_01 +0000000000004000_46800000_00 +100000000001003E_5D800000_01 +00000000000003AC_446B0000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000003_01 +00000044A3A3DBE5_52894747_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_D9FFFE09_01 +FFFFFFFFFFFF1A91_C7656F00_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_D503C001_01 +0000000000003309_464C2400_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF7_01 +FFFFFFFFFFFFFF58_C3280000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_D207F801_01 +0000000000002980_46260000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF07F_01 +000000000000005D_42BA0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF7F_01 +FFFC8C23DA2CEAD8_D85CF70A_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_DE000000_01 +FFFFFDE3C1DEC43C_D4070F89_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_D77FFFF5_01 +000000000030FFBE_4A43FEF8_00 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_D7FFFFFD_01 +FFFFFFFFEFDEED86_CD810894_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_DD400001_01 +000000001DA3FF45_4DED1FFA_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_CF7FFF00_01 +FFFFFFFE9B1BCB54_CFB2721B_01 +0000000008000000_4D000000_00 +00004000004001FE_56800000_01 +F27DD19DE6563714_DD5822E7_01 +0000000010000000_4D800000_00 +FFC00000004007FE_DA800000_01 +000000000001A359_47D1AC80_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C70003F_01 +FFFFFFFFFE62EC20_CBCE89F0_00 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E7FFFFF_01 +000000000000285F_46217C00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_CE800020_01 +FFFFF836F99DBAA8_D4F920CD_01 +0000000100000000_4F800000_00 +00000020003FFEFE_520000FF_01 +0033466832042D47_5A4D19A0_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_C4EF2000_00 +00000000003829C8_4A60A720_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_557FFFFF_01 +0000000FB77C672B_517B77C6_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D0003FF_01 +0000000000001B78_45DBC000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_DB000001_01 +0000000000000071_42E20000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_559FFFFF_01 +FFFFFFFFFFFFFF86_C2F40000_00 +0000004000000000_52800000_00 +0800000000040800_5D000000_01 +FFF8A60D9E19F17E_D8EB3E4D_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +FFFFFFFFF7506DBA_CD0AF925_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_C7820480_00 +FFFFFFFFFEA42AC9_CBADEA9C_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_5583FFFF_01 +FFE7AA3F2BDACC89_D9C2AE07_01 +0000040000000000_54800000_00 +FFF8040000040000_D8FF8000_01 +FFFFFFFFFFFFFFFD_C0400000_00 +0000080000000000_55000000_00 +FFFF80000800001F_D6FFFFF0_01 +FFFDF681DECDADC9_D8025F89_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_D3800010_01 +FFFFFFFFFFFFCFBE_C6410800_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51101FFF_01 +FEC01FECA24DE1B0_DB9FF00A_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_DD000001_01 +F858A66761669936_DCF4EB34_01 +0000800000000000_57000000_00 +FFFEFF800000003E_D7804000_01 +F716EA43FAC45C97_DD0E915C_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_C2680000_00 +0024D70EC7661FD8_5A135C3B_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_DE7E0001_01 +FFD956DBD0AEE817_DA1AA491_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FB_01 +FFFFFFFFFFFF4300_C73D0000_00 +0008000000000000_59000000_00 +4000000004002000_5E800000_01 +C12EDF40F41F6021_DE7B4483_01 +0010000000000000_59800000_00 +FF9000000000001D_DAE00000_01 +FFFFFFF83DE950F6_D0F842D6_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_DEFFFFF9_01 +FE2B59CB3A604D69_DBEA531B_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5EFFFFFF_01 +000000A37C210862_53237C21_01 +0080000000000000_5B000000_00 +0002000002000002_58000000_01 +FFFFB65CD8617789_D6934650_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55DFFFFF_01 +FFFFFFFFFFFFF01D_C57E3000_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800004_01 +000000000D098D19_4D5098D1_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C7FFFFF_01 +000006B3BD2C7BEF_54D677A5_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFEFF_01 +FFFF4E5ADDDAA4A8_D731A523_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE00_01 +FFFFFFFFFFFFFF21_C35F0000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83BFFF_01 +FFFFFFFFFC648262_CC66DF68_01 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_DE7FFF81_01 +FFFFFF7353AC45D2_D30CAC54_01 +8000000000000000_DF000000_00 +FFFFFFFFFFE7EFFF_C9C08008_00 +0000000000A1202D_4B21202D_00 +C000000000000000_DE800000_00 +FFFFFFFFFFFF5F7F_C7208100_00 +000000000040CA70_4A8194E0_00 +E000000000000000_DE000000_00 +0000200201FFFFFE_56000807_01 +00000003B55D87D4_506D5761_01 +F000000000000000_DD800000_00 +FF80000DFFFFFFFF_DAFFFFE5_01 +000000010510FAEF_4F82887D_01 +F800000000000000_DD000000_00 +0003FFF00000000F_587FFC00_01 +000000000000724A_46E49400_00 +FC00000000000000_DC800000_00 +FFFFFFDF80000002_D2020000_01 +0000000000000064_42C80000_00 +FE00000000000000_DC000000_00 +FEFFFFFFFFF800FE_DB800001_01 +FFFFFFC2C6222702_D274E778_01 +FF00000000000000_DB800000_00 +0000000408000002_50810000_01 +000000E96DF1CB41_53696DF1_01 +FF80000000000000_DB000000_00 +007FFFFFFFFFF9FE_5AFFFFFF_01 +F727F174DEE7DC85_DD0D80E9_01 +FFC0000000000000_DA800000_00 +8000000003FFFEFE_DF000000_01 +FFFFFFFFFFF0BD5B_C9742A50_00 +FFE0000000000000_DA000000_00 +0BEFFFFFFFFFFFFF_5D3EFFFF_01 +000000000002790C_481E4300_00 +FFF0000000000000_D9800000_00 +FFFFFFFFFFEFFBFA_C9802030_00 +000000169E75DF01_51B4F3AE_01 +FFF8000000000000_D9000000_00 +00000007FEFFDFFF_50FFDFFB_01 +000000000000000E_41600000_00 +FFFC000000000000_D8800000_00 +0003FFFE0007FFFE_587FFF80_01 +FFFFFFFFFFF28622_C9579DE0_00 +FFFE000000000000_D8000000_00 +FFFFFF7FFFFDF7FF_D3000003_01 +00072F0EC496FE21_58E5E1D8_01 +FFFF000000000000_D7800000_00 +DFBFFFFFFFFFFFFE_DE010001_01 +0000000000FC1FCA_4B7C1FCA_00 +FFFF800000000000_D7000000_00 +00000FFF800FFFFE_557FF800_01 +FFFF5194E4A9C2CE_D72E6B1C_01 +FFFFC00000000000_D6800000_00 +00000002100007FD_50040001_01 +FFFFFFFFFFC2D8FE_CA749C08_00 +FFFFE00000000000_D6000000_00 +000000000007FF6E_48FFEDC0_00 +000000000001766E_47BB3700_00 +FFFFF00000000000_D5800000_00 +0040000400000002_5A800008_01 +0000000000007841_46F08200_00 +FFFFF80000000000_D5000000_00 +3DFFFFFFFFFFFF7E_5E77FFFF_01 +FFFFFFE549E17E30_D1D5B0F5_01 +FFFFFC0000000000_D4800000_00 +FFFFFFFFFFFFFEE1_C38F8000_00 +FFFFFFFFFFFFFFE7_C1C80000_00 +FFFFFE0000000000_D4000000_00 +000000000EFFFFDF_4D6FFFFD_01 +FFFFFFFFFFFFFF73_C30D0000_00 +FFFFFF0000000000_D3800000_00 +FD00000008000000_DC400000_01 +000000000001DBB1_47EDD880_00 +FFFFFF8000000000_D3000000_00 +FFFFFFFFFFF8007F_C8FFF020_00 +FFFFFFFEFD10A515_CF8177AE_01 +FFFFFFC000000000_D2800000_00 +FFEFFFFFFFFFFFFE_D9800001_01 +FAB02984F6283B6C_DCA9FAD0_01 +FFFFFFE000000000_D2000000_00 +FFFFFFBC000001FE_D2880000_01 +FEB087C6B9FE7FE0_DBA7BC1D_01 +FFFFFFF000000000_D1800000_00 +FFF80001000007FE_D8FFFFE0_01 +00F2762EA6837956_5B72762E_01 +FFFFFFF800000000_D1000000_00 +FFF7E0FFFFFFFFFE_D901F001_01 +00002E1175484626_563845D5_01 +FFFFFFFC00000000_D0800000_00 +0000200020000FFE_56000080_01 +000000000000068F_44D1E000_00 +FFFFFFFE00000000_D0000000_00 +021FFFFFFFFBFFFF_5C07FFFF_01 +FFFFFFFFFFFFFFF9_C0E00000_00 +FFFFFFFF00000000_CF800000_00 +FFFFFFD0000FFFFD_D23FFFC1_01 +000000BDF6658B83_533DF665_01 +FFFFFFFF80000000_CF000000_00 +1000001FFDFFFFFF_5D800000_01 +0000000000003B5B_466D6C00_00 +FFFFFFFFC0000000_CE800000_00 +FFFFFFBFFE0FFFFF_D28003E1_01 +FFFFFFFFFFFFFFF0_C1800000_00 +FFFFFFFFE0000000_CE000000_00 +FFFFFFFBF00007FF_D0820000_01 +01E986274F48EAAD_5BF4C313_01 +FFFFFFFFF0000000_CD800000_00 +1FFFFFFDFFFFFF7F_5DFFFFFF_01 +FFFFFFFFFFFFCB5A_C6529800_00 +FFFFFFFFF8000000_CD000000_00 +7FF000000000FFFF_5EFFE000_01 +00000003C2717FC3_50709C5F_01 +FFFFFFFFFC000000_CC800000_00 +FFFFFFE00008001F_D1FFFFC0_01 +FFFFFFFFFFEFABDA_C982A130_00 +FFFFFFFFFE000000_CC000000_00 +0200000000000002_5C000000_01 +FFFFFFFFF8FDA53F_CCE04B59_01 +FFFFFFFFFF000000_CB800000_00 +F6000003FFFFFFFE_DD200000_01 +FFFFFFFFFFFFFFD0_C2400000_00 +FFFFFFFFFF800000_CB000000_00 +FFFFFFFFFFBFFF7E_CA800104_00 +00000000EE0FEA62_4F6E0FEA_01 +FFFFFFFFFFC00000_CA800000_00 +0000007FFF9FFFFD_52FFFF3F_01 +00000037F35EDC1D_525FCD7B_01 +FFFFFFFFFFE00000_CA000000_00 +FFFFFFF7FDFFFF7D_D1002001_01 +00000000000001AD_43D68000_00 +FFFFFFFFFFF00000_C9800000_00 +FFFFFF0000100020_D37FFFF0_01 +27F167FBC7FC5F9A_5E1FC59F_01 +FFFFFFFFFFF80000_C9000000_00 +003FFFFFFFFC0001_5A7FFFFF_01 +000E48F9F4EBD30E_59648F9F_01 +FFFFFFFFFFFC0000_C8800000_00 +DFFFFFFFFFFBFFFE_DE000001_01 +FC91C23EE8C9424F_DC5B8F71_01 +FFFFFFFFFFFE0000_C8000000_00 +F7DFFBFFFFFFFFFE_DD020041_01 +000000002CAE080C_4E32B820_01 +FFFFFFFFFFFF0000_C7800000_00 +FFFFC00010000020_D67FFFC0_01 +04D921F917B20E40_5C9B243F_01 +FFFFFFFFFFFF8000_C7000000_00 +F8000FFFFFFFFFFD_DCFFFE01_01 +FFF17C566BC7D811_D9683A9A_01 +FFFFFFFFFFFFC000_C6800000_00 +00000000000000FE_437E0000_00 +FFF82AC14930D386_D8FAA7D7_01 +FFFFFFFFFFFFE000_C6000000_00 +00000000000003FC_447F0000_00 +000E62EC60E119FC_59662EC6_01 +FFFFFFFFFFFFF000_C5800000_00 +FFFFEFF7FF7FFFFE_D5804005_01 +0E2B1ECF210EEDC5_5D62B1EC_01 +FFFFFFFFFFFFF800_C5000000_00 +00000000007FFF1F_4AFFFE3E_00 +FFFFFE534F5676F7_D3D65855_01 +FFFFFFFFFFFFFC00_C4800000_00 +0000001004FFFFFD_518027FF_01 +0000035C939669F1_545724E5_01 +FFFFFFFFFFFFFE00_C4000000_00 +1FFFFFFFFFFFFDFD_5DFFFFFF_01 +FFFFFFFFFFFFFF91_C2DE0000_00 +FFFFFFFFFFFFFF00_C3800000_00 +01FFFFFFFBFFEFFE_5BFFFFFF_01 +000000000000016E_43B70000_00 +FFFFFFFFFFFFFF80_C3000000_00 +FFF7FFFFFFFFF7FD_D9000001_01 +FFFFF8E2BCFAC553_D4E3A861_01 +FFFFFFFFFFFFFFC0_C2800000_00 +FFFFFBFFFFFE0FFE_D4800001_01 +00000001A4E704BF_4FD27382_01 +FFFFFFFFFFFFFFE0_C2000000_00 +1400007FFFFFFFFD_5DA00003_01 +FFFFFFFC93B187B4_D05B139F_01 +FFFFFFFFFFFFFFF0_C1800000_00 +40000000007FFFFD_5E800000_01 +000000000067D468_4ACFA8D0_00 +FFFFFFFFFFFFFFF8_C1000000_00 +007FFEFFFFFBFFFE_5AFFFDFF_01 +FFFFFFE26CEC79F8_D1EC989D_01 +FFFFFFFFFFFFFFFC_C0800000_00 +00FFFFFF000000FF_5B7FFFFF_01 +FFFFFFFFE0D3983A_CDF9633F_01 +FFFFFFFFFFFFFFFE_C0000000_00 +00007FFFBFFF7FFE_56FFFF7F_01 +FFFFFFFDF4A7088A_D002D63E_01 +FFFFFFFFFFFFFFFF_BF800000_00 +000008000000027E_55000000_01 +000000000000F4E8_4774E800_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFF83FFDF_CAF80042_00 +00000E11407887B2_55611407_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +04000003FFFFFFF6_5C800000_01 +0000000000000513_44A26000_00 +FFFFFFFFFFFFFFF7_C1100000_00 +BFFC00000000003E_DE800800_01 +00000008D7BBB75B_510D7BBB_01 +FFFFFFFFFFFFFFEF_C1880000_00 +000FFFFBFFFC0000_597FFFBF_01 +FFFFFFFFFFCD5A23_CA4A9774_00 +FFFFFFFFFFFFFFDF_C2040000_00 +FFBFDFFFBFFFFFFF_DA804001_01 +000000000000007F_42FE0000_00 +FFFFFFFFFFFFFFBF_C2820000_00 +00000007FF800003_50FFF000_01 +000000000002BB02_482EC080_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEE7FF_C78C0080_00 +00264B2B9BAD0DA2_5A192CAE_01 +FFFFFFFFFFFFFEFF_C3808000_00 +0000000000100803_49804018_00 +FF9B1DCB9F857D5E_DAC9C469_01 +FFFFFFFFFFFFFDFF_C4004000_00 +FFFFFFBFFFFFEFEE_D2800001_01 +F6FD7542899C1C6F_DD1028AC_01 +FFFFFFFFFFFFFBFF_C4802000_00 +FF800000004001FF_DB000000_01 +0000000002BE4932_4C2F924C_01 +FFFFFFFFFFFFF7FF_C5001000_00 +00001004000FFFFE_55802000_01 +FFFFFF9DAA0123E0_D2C4ABFE_01 +FFFFFFFFFFFFEFFF_C5800800_00 +00000001FDFFFDFE_4FFEFFFE_01 +FFFC1C8703B1DCB0_D878DE40_01 +FFFFFFFFFFFFDFFF_C6000400_00 +FE0FE00000000000_DBF81000_00 +0779ED944A4E2779_5CEF3DB2_01 +FFFFFFFFFFFFBFFF_C6800200_00 +FBFFFE0400000000_DC800040_01 +0000010127E03666_538093F0_01 +FFFFFFFFFFFF7FFF_C7000100_00 +FFFFF0200000FFFE_D57E0000_01 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEFFFF_C7800080_00 +FFEFFE0000080000_D9801000_01 +FFFFFFFFFD3354EA_CC332AC6_01 +FFFFFFFFFFFDFFFF_C8000040_00 +003FF0000003FFFE_5A7FC000_01 +0000006375B23F7B_52C6EB64_01 +FFFFFFFFFFFBFFFF_C8800020_00 +000407FFFFFFFFF6_5880FFFF_01 +0000000092117F38_4F12117F_01 +FFFFFFFFFFF7FFFF_C9000010_00 +FFFFFFFFFFFF7FFF_C7000100_00 +00000000000008BE_450BE000_00 +FFFFFFFFFFEFFFFF_C9800008_00 +004000020FFFFFFF_5A800004_01 +FFFFB84C2D8BC9CB_D68F67A5_01 +FFFFFFFFFFDFFFFF_CA000004_00 +00FFFFFFFFFFFFFD_5B7FFFFF_01 +00000023C2C6F284_520F0B1B_01 +FFFFFFFFFFBFFFFF_CA800002_00 +FFFDDFFFFFFFFFFD_D8080001_01 +00000000746356C4_4EE8C6AD_01 +FFFFFFFFFF7FFFFF_CB000001_00 +010000000000BFFF_5B800000_01 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFEFFFFFF_CB800001_01 +FFFFBF7FFBFFFFFE_D6810009_01 +00000006386CE889_50C70D9D_01 +FFFFFFFFFDFFFFFF_CC000001_01 +F00000F7FFFFFFFF_DD7FFFF1_01 +FFFDFC53090C46A4_D800EB3E_01 +FFFFFFFFFBFFFFFF_CC800001_01 +0000000000800047_4B000047_00 +FFFFFFFFD693872E_CE25B1E4_01 +FFFFFFFFF7FFFFFF_CD000001_01 +000000007FBFFBFF_4EFF7FF7_01 +00000026A7845E35_521A9E11_01 +FFFFFFFFEFFFFFFF_CD800001_01 +FFFFFFDFFFFFFBFD_D2000001_01 +000000001433D14C_4DA19E8A_01 +FFFFFFFFDFFFFFFF_CE000001_01 +0001FFFFFFE0000E_57FFFFFF_01 +F0F23E8068D3D84A_DD70DC18_01 +FFFFFFFFBFFFFFFF_CE800001_01 +F7FFBFFFFFFFBFFF_DD000401_01 +FFFFBD29B7459087_D685AC92_01 +FFFFFFFF7FFFFFFF_CF000001_01 +FFFFFFF8FFFFBFFF_D0E00009_01 +FFFFFFFFFFEDDC06_C9911FD0_00 +FFFFFFFEFFFFFFFF_CF800001_01 +FFFFFFF80001FFFF_D0FFFFC1_01 +0000000000002FF9_463FE400_00 +FFFFFFFDFFFFFFFF_D0000001_01 +004000040000FFFF_5A800008_01 +FFFFFFFFFFFFFFF1_C1700000_00 +FFFFFFFBFFFFFFFF_D0800001_01 +C0000000007FFFFA_DE800000_01 +FFFFFFFFFE053E2B_CBFD60EB_01 +FFFFFFF7FFFFFFFF_D1000001_01 +7FFE000007FFFFFF_5EFFFC00_01 +000000000000000D_41500000_00 +FFFFFFEFFFFFFFFF_D1800001_01 +F80000000001007E_DD000000_01 +FFFFED48424AD9D6_D595BDEE_01 +FFFFFFDFFFFFFFFF_D2000001_01 +FFFFFE0001FEFFFF_D3FFFF01_01 +000000000000013B_439D8000_00 +FFFFFFBFFFFFFFFF_D2800001_01 +0007FBFFFFFDFFFE_58FF7FFF_01 +4A16BD4128090C83_5E942D7A_01 +FFFFFF7FFFFFFFFF_D3000001_01 +00FFF7FFFF7FFFFE_5B7FF7FF_01 +0000000000000006_40C00000_00 +FFFFFEFFFFFFFFFF_D3800001_01 +FBFFFFBFFFBFFFFF_DC800009_01 +00000000000001BA_43DD0000_00 +FFFFFDFFFFFFFFFF_D4000001_01 +0000000040000082_4E800001_01 +FF07A2BF5B689F89_DB785D41_01 +FFFFFBFFFFFFFFFF_D4800001_01 +0000001FF8000008_51FFC000_01 +F87CAA7DE672DE8B_DCF06AB1_01 +FFFFF7FFFFFFFFFF_D5000001_01 +07FFF80000000002_5CFFFF00_01 +0000000010A1E5B8_4D850F2D_01 +FFFFEFFFFFFFFFFF_D5800001_01 +F7FFFFE00007FFFF_DD000002_01 +FFFFFFFFFFF6ADFC_C9152040_00 +FFFFDFFFFFFFFFFF_D6000001_01 +FFFFFF03FFFFFFC0_D37C0001_01 +EA579475948F0032_DDAD435D_01 +FFFFBFFFFFFFFFFF_D6800001_01 +FC00000000003FF6_DC800000_01 +002E677AC313BF60_5A399DEB_01 +FFFF7FFFFFFFFFFF_D7000001_01 +02000007FF7FFFFF_5C000001_01 +0000000E999639F1_51699963_01 +FFFEFFFFFFFFFFFF_D7800001_01 +FFFF83FFFFFFFFBE_D6F80001_01 +000000000001537D_47A9BE80_00 +FFFDFFFFFFFFFFFF_D8000001_01 +EFFFFFC00000003D_DD800002_01 +FFFFFFF21FEDFD35_D15E0121_01 +FFFBFFFFFFFFFFFF_D8800001_01 +FFFFFFF0000007FE_D1800000_01 +FFFFFFFFFFDE0839_CA07DF1C_00 +FFF7FFFFFFFFFFFF_D9000001_01 +0000007FFFE000FF_52FFFFC0_01 +FFFFFFFF79F30F48_CF060CF1_01 +FFEFFFFFFFFFFFFF_D9800001_01 +FFFFFC13FFFFFFFD_D47B0001_01 +0000000000001B85_45DC2800_00 +FFDFFFFFFFFFFFFF_DA000001_01 +000008000007FFFE_55000000_01 +12DB4409E5AE87E6_5D96DA20_01 +FFBFFFFFFFFFFFFF_DA800001_01 +FFFFFFFFFFF7BFEE_C9040120_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FF7FFFFFFFFFFFFF_DB000001_01 +000000001040FFFE_4D8207FF_01 +00000909A09C13D3_55109A09_01 +FEFFFFFFFFFFFFFF_DB800001_01 +FFFFFF01FFFFFF7F_D37E0001_01 +FFFFFF72E7D2575D_D30D182E_01 +FDFFFFFFFFFFFFFF_DC000001_01 +FFFFFFFFFFFEFFDB_C7801280_00 +0000000000000017_41B80000_00 +FBFFFFFFFFFFFFFF_DC800001_01 +100000001FFFFFF6_5D800000_01 +000000114B12EF51_518A5897_01 +F7FFFFFFFFFFFFFF_DD000001_01 +0407FFFFFFFFFEFF_5C80FFFF_01 +FFFFFF769F3A5C2C_D30960C6_01 +EFFFFFFFFFFFFFFF_DD800001_01 +FFFFFFFDF7FFFFFD_D0020001_01 +FFFFFFFFFFFFFFF2_C1600000_00 +DFFFFFFFFFFFFFFF_DE000001_01 +FFFFFFFFFE0007FF_CBFFFC01_01 +000000000000001E_41F00000_00 +BFFFFFFFFFFFFFFF_DE800001_01 +FFF800000009FFFF_D9000000_01 +0000000000007AA4_46F54800_00 +7FFFFFFFFFFFFFFF_5EFFFFFF_01 +4080000000FFFFFF_5E810000_01 +000000000DE7601D_4D5E7601_01 +3FFFFFFFFFFFFFFF_5E7FFFFF_01 +FFCFFFFFFFBFFFFE_DA400001_01 +FFFFFFFFFFFFFFCA_C2580000_00 +1FFFFFFFFFFFFFFF_5DFFFFFF_01 +000080400000003F_57004000_01 +00000000001F75A5_49FBAD28_00 +0FFFFFFFFFFFFFFF_5D7FFFFF_01 +FFFFFFEFFFFFCFFE_D1800002_01 +FFFFFEE775887420_D38C453C_01 +07FFFFFFFFFFFFFF_5CFFFFFF_01 +00000000000801FE_49001FE0_00 +0000000000213FF1_4A04FFC4_00 +03FFFFFFFFFFFFFF_5C7FFFFF_01 +07FEFFFFFFFFFFEE_5CFFDFFF_01 +0000000000000004_40800000_00 +01FFFFFFFFFFFFFF_5BFFFFFF_01 +0000000820000003_51020000_01 +FFFFFFF9AD105214_D0CA5DF6_01 +00FFFFFFFFFFFFFF_5B7FFFFF_01 +FFFFF00FFFFFFFBE_D57F0001_01 +FFFFFFFFFFCC48E7_CA4EDC64_00 +007FFFFFFFFFFFFF_5AFFFFFF_01 +00000FFFEF7FFFFF_557FFEF7_01 +FFFFFFFFFF0BA6CB_CB745935_00 +003FFFFFFFFFFFFF_5A7FFFFF_01 +FFFFFF7FBFFFFFBF_D3004001_01 +FFFFFFFFFFF24425_C95BBDB0_00 +001FFFFFFFFFFFFF_59FFFFFF_01 +200000001FFBFFFF_5E000000_01 +FFFFFF4E7115EC53_D3318EEB_01 +000FFFFFFFFFFFFF_597FFFFF_01 +FFFFF803FFFFFFBF_D4FF8001_01 +FFFFFC2E539ADCFE_D4746B1A_01 +0007FFFFFFFFFFFF_58FFFFFF_01 +FFFFFFFFFBFFFFFF_CC800001_01 +00000055084732F3_52AA108E_01 +0003FFFFFFFFFFFF_587FFFFF_01 +BFFF7FFFFFFFFE00_DE800101_01 +FFFFFFFFFFFF8543_C6F57A00_00 +0001FFFFFFFFFFFF_57FFFFFF_01 +0000001FFBFFE000_51FFDFFF_00 +FFFFFFFFFFFE491B_C7DB7280_00 +0000FFFFFFFFFFFF_577FFFFF_01 +FC00200000001FFE_DC7FF800_01 +FFFFF16898822A24_D5697678_01 +00007FFFFFFFFFFF_56FFFFFF_01 +3FFF03FFFFFFFFFE_5E7FFC0F_01 +FFFFFF8FFE18C7BF_D2E003CF_01 +00003FFFFFFFFFFF_567FFFFF_01 +FFFFFEFFFEFFFFFD_D3800081_01 +00F03620C1266ED9_5B703620_01 +00001FFFFFFFFFFF_55FFFFFF_01 +BF7EFFFFFFFFFFFF_DE810201_01 +FFFFFFFFFFFFFFD5_C22C0000_00 +00000FFFFFFFFFFF_557FFFFF_01 +FFFBFFFFF803FFFE_D8800001_01 +0000000000068684_48D0D080_00 +000007FFFFFFFFFF_54FFFFFF_01 +DFFFFFE00000001E_DE000001_01 +FFFFFFFFFFFFECF5_C5985800_00 +000003FFFFFFFFFF_547FFFFF_01 +FFFF00400000FFFF_D77FC000_01 +0000000000000002_40000000_00 +000001FFFFFFFFFF_53FFFFFF_01 +FBFFFFFFFFFFBDFE_DC800001_01 +0000000000000BC9_453C9000_00 +000000FFFFFFFFFF_537FFFFF_01 +807FFFFFFFFFDFFE_DEFF0001_01 +FFC274E35A70CD76_DA762C73_01 +0000007FFFFFFFFF_52FFFFFF_01 +0FFFFFFFFEFFFFFD_5D7FFFFF_01 +FFFFFFFF00E73AFC_CF7F18C6_01 +0000003FFFFFFFFF_527FFFFF_01 +FFC000000001000E_DA800000_01 +FFFFFFFFFFFE15E9_C7F50B80_00 +0000001FFFFFFFFF_51FFFFFF_01 +0001FFFFFFFFF3FD_57FFFFFF_01 +0000000000000033_424C0000_00 +0000000FFFFFFFFF_517FFFFF_01 +000000001FFFBFFF_4DFFFDFF_01 +FFFFFFEE6B141E1B_D18CA760_01 +00000007FFFFFFFF_50FFFFFF_01 +FFFFFFFFF60007FF_CD1FFF81_01 +00000001AB310BA6_4FD59885_01 +00000003FFFFFFFF_507FFFFF_01 +0003FFFFB7FFFFFF_587FFFED_01 +FFFFFFFFFFFFF195_C566B000_00 +00000001FFFFFFFF_4FFFFFFF_01 +FFFFFFFF8000000B_CF000000_01 +00000019BA8D5559_51CDD46A_01 +00000000FFFFFFFF_4F7FFFFF_01 +FBFEFFFFFFFFFFF9_DC802001_01 +FFFFFFB6F062822D_D2921F3B_01 +000000007FFFFFFF_4EFFFFFF_01 +0001000000000082_57800000_01 +01CEAD9E2FB104A4_5BE756CF_01 +000000003FFFFFFF_4E7FFFFF_01 +000003FFFFFFFF7C_547FFFFF_01 +FFFFFFFFFD681E78_CC25F862_00 +000000001FFFFFFF_4DFFFFFF_01 +00002000400001FF_56000100_01 +0000000000000018_41C00000_00 +000000000FFFFFFF_4D7FFFFF_01 +3FFF80000000003E_5E7FFE00_01 +FFFFFFFFFFFFFF95_C2D60000_00 +0000000007FFFFFF_4CFFFFFF_01 +010000BFFFFFFFFF_5B80005F_01 +0000001697087B19_51B4B843_01 +0000000003FFFFFF_4C7FFFFF_01 +FBFFFFFFFFEEFFFD_DC800001_01 +0000000E64BDFC55_51664BDF_01 +0000000001FFFFFF_4BFFFFFF_01 +FC00000001FFFFFE_DC800000_01 +FFFED156A62AB849_D79754AD_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_D0F80201_01 +00015354EAE7C259_57A9AA75_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFF0F4DF3C75_D170B20D_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_D8C00000_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_CB0001C0_00 +FFFFFFDB5433CB9B_D212AF31_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_D4000801_01 +FFFFFFFFFFDEAE1F_CA054784_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_CD7F8000_01 +FFFFFFFE7735DEC7_CFC46511_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFDFFFF_01 +000003757D8B12ED_545D5F62_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_D3FC0401_01 +00000A654064E046_55265406_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000000_01 +FFFFFFFFFFFFFFE7_C1C80000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5CFFFFFF_01 +FFFFAD78B3D6C3B6_D6A50E99_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +FFFFFFF70B77F34F_D10F4881_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_D2FFFF21_01 +0000013EB4D67EC8_539F5A6B_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_DE800041_01 +0005CEAF34EA1DC7_58B9D5E6_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900000_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000360D0_48583400_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B801FFF_01 +00C000708FF1BA51_5B400070_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_DCFFC000_01 +0F9E07DCC0BDC061_5D79E07D_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC000_01 +FFFFFFE1B9B2A079_D1F2326B_01 +000000000000003F_427C0000_00 +FFF80000000080FF_D9000000_01 +00000000001EB5B4_49F5ADA0_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +00000000005AC607_4AB58C0E_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_CF840000_01 +000005C5B9D66984_54B8B73A_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_DE7FF801_01 +00001D06B372AA06_55E8359B_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_rne.tv b/wally-pipelined/testbench/fp/i64_f32_rne.tv index e766e9aec..14a3a96af 100644 --- a/wally-pipelined/testbench/fp/i64_f32_rne.tv +++ b/wally-pipelined/testbench/fp/i64_f32_rne.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 5CFFFFC0_01 -0000000032CC8B7A 4E4B322E_01 -0000000000000000 00000000_00 -FFFFFFFFC0003FFE CE7FFF00_01 -032C857F319EDE38 5C4B2160_01 -0000000000000001 3F800000_00 -FFFFFBFFFFF8003E D4800001_01 -00394C79B6D3007B 5A6531E7_01 -0000000000000002 40000000_00 -FBFFFFF0000001FF DC800002_01 -0000000001AE458D 4BD722C6_01 -0000000000000004 40800000_00 -00040008000007FE 58800100_01 -F9EB456140D88764 DCC29754_01 -0000000000000008 41000000_00 -FFFFE400FFFFFFFE D5DFF800_01 -07DE834A248EDF36 5CFBD069_01 -0000000000000010 41800000_00 -00000003FF001FFF 507FC008_01 -FFFFFFFFFFE385E2 C9E3D0F0_00 -0000000000000020 42000000_00 -F0041FFFFFFFFFFF DD7FBE00_01 -000000059EB1FD45 50B3D640_01 -0000000000000040 42800000_00 -FFFFFFFFFFFCFFF9 C84001C0_00 -FFFFFFFFFFFEDDFE C7910100_00 -0000000000000080 43000000_00 -000000000003FF00 487FC000_00 -00000000C89FF56B 4F489FF5_01 -0000000000000100 43800000_00 -000FFFFF7FDFFFFF 597FFFF8_01 -1B5E4F0BE0DEBFF0 5DDAF278_01 -0000000000000200 44000000_00 -FFFDF803FFFFFFFF D801FF00_01 -FFFFFFFFFFF4766B C9389950_00 -0000000000000400 44800000_00 -0000080100000FFE 55001000_01 -000000000000000C 41400000_00 -0000000000000800 45000000_00 -0048000000100000 5A900000_01 -FFE662A109109D0A D9CCEAF8_01 -0000000000001000 45800000_00 -C000000037FFFFFE DE800000_01 -FFFFFFFFFFFFFFE4 C1E00000_00 -0000000000002000 46000000_00 -F801000000100000 DCFFE000_01 -FE114B79075F70EE DBF75A43_01 -0000000000004000 46800000_00 -100000000001003E 5D800000_01 -00000000000003AC 446B0000_00 -0000000000008000 47000000_00 -200000FFFFFFF800 5E000004_01 -00000044A3A3DBE5 52894748_01 -0000000000010000 47800000_00 -FFE0003EFFFFFFFF D9FFFE08_01 -FFFFFFFFFFFF1A91 C7656F00_00 -0000000000020000 48000000_00 -FFFFF7C3FFFFFFFD D503C000_01 -0000000000003309 464C2400_00 -0000000000040000 48800000_00 -000083FFF7FFFFFE 5703FFF8_01 -FFFFFFFFFFFFFF58 C3280000_00 -0000000000080000 49000000_00 -FFFFFFDE01FFFFFE D207F800_01 -0000000000002980 46260000_00 -0000000000100000 49800000_00 -00000000FFF07FFF 4F7FF080_01 -000000000000005D 42BA0000_00 -0000000000200000 4A000000_00 -000020FFDFFFFFFF 5603FF80_01 -FFFC8C23DA2CEAD8 D85CF709_01 -0000000000400000 4A800000_00 -E0000000003FFFDF DE000000_01 -FFFFFDE3C1DEC43C D4070F88_01 -0000000000800000 4B000000_00 -FFFF00000BFFFFFD D77FFFF4_01 -000000000030FFBE 4A43FEF8_00 -0000000001000000 4B800000_00 -FFFE000007FFEFFD D7FFFFFC_01 -FFFFFFFFEFDEED86 CD810894_01 -0000000002000000 4C000000_00 -F3FFFFFFFFBFFFFE DD400000_01 -000000001DA3FF45 4DED1FFA_01 -0000000004000000 4C800000_00 -FFFFFFFF00010007 CF7FFF00_01 -FFFFFFFE9B1BCB54 CFB2721A_01 -0000000008000000 4D000000_00 -00004000004001FE 56800001_01 -F27DD19DE6563714 DD5822E6_01 -0000000010000000 4D800000_00 -FFC00000004007FE DA800000_01 -000000000001A359 47D1AC80_00 -0000000020000000 4E000000_00 -0000000003C000FE 4C700040_01 -FFFFFFFFFE62EC20 CBCE89F0_00 -0000000040000000 4E800000_00 -000000003FFFFFFD 4E800000_01 -000000000000285F 46217C00_00 -0000000080000000 4F000000_00 -FFFFFFFFBFFFF00F CE800020_01 -FFFFF836F99DBAA8 D4F920CC_01 -0000000100000000 4F800000_00 -00000020003FFEFE 52000100_01 -0033466832042D47 5A4D19A1_01 -0000000200000000 50000000_00 -FFFFFFFFFFFFF887 C4EF2000_00 -00000000003829C8 4A60A720_00 -0000000400000000 50800000_00 -00000FFFFFFF7DFD 55800000_01 -0000000FB77C672B 517B77C6_01 -0000000800000000 51000000_00 -08003FFDFFFFFFFE 5D000400_01 -0000000000001B78 45DBC000_00 -0000001000000000 51800000_00 -FF7FFFFFFFEFDFFF DB000000_01 -0000000000000071 42E20000_00 -0000002000000000 52000000_00 -000013FFFFFFFDFF 55A00000_01 -FFFFFFFFFFFFFF86 C2F40000_00 -0000004000000000 52800000_00 -0800000000040800 5D000000_01 -FFF8A60D9E19F17E D8EB3E4C_01 -0000008000000000 53000000_00 -000077FFF0000000 56EFFFE0_00 -FFFFFFFFF7506DBA CD0AF924_01 -0000010000000000 53800000_00 -FFFFFFFFFFFEFBF7 C7820480_00 -FFFFFFFFFEA42AC9 CBADEA9C_01 -0000020000000000 54000000_00 -0000107FFFFFDFFD 55840000_01 -FFE7AA3F2BDACC89 D9C2AE07_01 -0000040000000000 54800000_00 -FFF8040000040000 D8FF8000_01 -FFFFFFFFFFFFFFFD C0400000_00 -0000080000000000 55000000_00 -FFFF80000800001F D6FFFFF0_01 -FFFDF681DECDADC9 D8025F88_01 -0000100000000000 55800000_00 -FFFFFEFFFFE0007F D3800010_01 -FFFFFFFFFFFFCFBE C6410800_00 -0000200000000000 56000000_00 -0000000901FFFFFD 51102000_01 -FEC01FECA24DE1B0 DB9FF00A_01 -0000400000000000 56800000_00 -F7FFFFFFDFFF7FFF DD000000_01 -F858A66761669936 DCF4EB33_01 -0000800000000000 57000000_00 -FFFEFF800000003E D7804000_01 -F716EA43FAC45C97 DD0E915C_01 -0001000000000000 57800000_00 -FFFFFFFFFFFFFFC6 C2680000_00 -0024D70EC7661FD8 5A135C3B_01 -0002000000000000 58000000_00 -C07FFFFFFFFFFFFE DE7E0000_01 -FFD956DBD0AEE817 DA1AA491_01 -0004000000000000 58800000_00 -020003EFFFFFFFFE 5C0000FC_01 -FFFFFFFFFFFF4300 C73D0000_00 -0008000000000000 59000000_00 -4000000004002000 5E800000_01 -C12EDF40F41F6021 DE7B4483_01 -0010000000000000 59800000_00 -FF9000000000001D DAE00000_01 -FFFFFFF83DE950F6 D0F842D6_01 -0020000000000000 5A000000_00 -800003FFFFFC0000 DEFFFFF8_01 -FE2B59CB3A604D69 DBEA531A_01 -0040000000000000 5A800000_00 -7FFFFFFDFFFFBFFF 5F000000_01 -000000A37C210862 53237C21_01 -0080000000000000 5B000000_00 -0002000002000002 58000001_01 -FFFFB65CD8617789 D693464F_01 -0100000000000000 5B800000_00 -00001BFFFFFFBFFE 55E00000_01 -FFFFFFFFFFFFF01D C57E3000_00 -0200000000000000 5C000000_00 -1000008000003FFF 5D800004_01 -000000000D098D19 4D5098D2_01 -0400000000000000 5C800000_00 -03FFFFFFFFFFF5FF 5C800000_01 -000006B3BD2C7BEF 54D677A6_01 -0800000000000000 5D000000_00 -00003FFFBFFFFFFE 567FFF00_01 -FFFF4E5ADDDAA4A8 D731A522_01 -1000000000000000 5D800000_00 -001FFFC000000FFD 59FFFE00_01 -FFFFFFFFFFFFFF21 C35F0000_00 -2000000000000000 5E000000_00 -0000000041DFFFFF 4E83C000_01 -FFFFFFFFFC648262 CC66DF68_01 -4000000000000000 5E800000_00 -C0001FFFFFFFFFFB DE7FFF80_01 -FFFFFF7353AC45D2 D30CAC54_01 -8000000000000000 DF000000_00 -FFFFFFFFFFE7EFFF C9C08008_00 -0000000000A1202D 4B21202D_00 -C000000000000000 DE800000_00 -FFFFFFFFFFFF5F7F C7208100_00 -000000000040CA70 4A8194E0_00 -E000000000000000 DE000000_00 -0000200201FFFFFE 56000808_01 -00000003B55D87D4 506D5762_01 -F000000000000000 DD800000_00 -FF80000DFFFFFFFF DAFFFFE4_01 -000000010510FAEF 4F82887D_01 -F800000000000000 DD000000_00 -0003FFF00000000F 587FFC00_01 -000000000000724A 46E49400_00 -FC00000000000000 DC800000_00 -FFFFFFDF80000002 D2020000_01 -0000000000000064 42C80000_00 -FE00000000000000 DC000000_00 -FEFFFFFFFFF800FE DB800000_01 -FFFFFFC2C6222702 D274E777_01 -FF00000000000000 DB800000_00 -0000000408000002 50810000_01 -000000E96DF1CB41 53696DF2_01 -FF80000000000000 DB000000_00 -007FFFFFFFFFF9FE 5B000000_01 -F727F174DEE7DC85 DD0D80E9_01 -FFC0000000000000 DA800000_00 -8000000003FFFEFE DF000000_01 -FFFFFFFFFFF0BD5B C9742A50_00 -FFE0000000000000 DA000000_00 -0BEFFFFFFFFFFFFF 5D3F0000_01 -000000000002790C 481E4300_00 -FFF0000000000000 D9800000_00 -FFFFFFFFFFEFFBFA C9802030_00 -000000169E75DF01 51B4F3AF_01 -FFF8000000000000 D9000000_00 -00000007FEFFDFFF 50FFDFFC_01 -000000000000000E 41600000_00 -FFFC000000000000 D8800000_00 -0003FFFE0007FFFE 587FFF80_01 -FFFFFFFFFFF28622 C9579DE0_00 -FFFE000000000000 D8000000_00 -FFFFFF7FFFFDF7FF D3000002_01 -00072F0EC496FE21 58E5E1D9_01 -FFFF000000000000 D7800000_00 -DFBFFFFFFFFFFFFE DE010000_01 -0000000000FC1FCA 4B7C1FCA_00 -FFFF800000000000 D7000000_00 -00000FFF800FFFFE 557FF801_01 -FFFF5194E4A9C2CE D72E6B1B_01 -FFFFC00000000000 D6800000_00 -00000002100007FD 50040002_01 -FFFFFFFFFFC2D8FE CA749C08_00 -FFFFE00000000000 D6000000_00 -000000000007FF6E 48FFEDC0_00 -000000000001766E 47BB3700_00 -FFFFF00000000000 D5800000_00 -0040000400000002 5A800008_01 -0000000000007841 46F08200_00 -FFFFF80000000000 D5000000_00 -3DFFFFFFFFFFFF7E 5E780000_01 -FFFFFFE549E17E30 D1D5B0F4_01 -FFFFFC0000000000 D4800000_00 -FFFFFFFFFFFFFEE1 C38F8000_00 -FFFFFFFFFFFFFFE7 C1C80000_00 -FFFFFE0000000000 D4000000_00 -000000000EFFFFDF 4D6FFFFE_01 -FFFFFFFFFFFFFF73 C30D0000_00 -FFFFFF0000000000 D3800000_00 -FD00000008000000 DC400000_01 -000000000001DBB1 47EDD880_00 -FFFFFF8000000000 D3000000_00 -FFFFFFFFFFF8007F C8FFF020_00 -FFFFFFFEFD10A515 CF8177AD_01 -FFFFFFC000000000 D2800000_00 -FFEFFFFFFFFFFFFE D9800000_01 -FAB02984F6283B6C DCA9FACF_01 -FFFFFFE000000000 D2000000_00 -FFFFFFBC000001FE D2880000_01 -FEB087C6B9FE7FE0 DBA7BC1D_01 -FFFFFFF000000000 D1800000_00 -FFF80001000007FE D8FFFFE0_01 -00F2762EA6837956 5B72762F_01 -FFFFFFF800000000 D1000000_00 -FFF7E0FFFFFFFFFE D901F000_01 -00002E1175484626 563845D5_01 -FFFFFFFC00000000 D0800000_00 -0000200020000FFE 56000080_01 -000000000000068F 44D1E000_00 -FFFFFFFE00000000 D0000000_00 -021FFFFFFFFBFFFF 5C080000_01 -FFFFFFFFFFFFFFF9 C0E00000_00 -FFFFFFFF00000000 CF800000_00 -FFFFFFD0000FFFFD D23FFFC0_01 -000000BDF6658B83 533DF666_01 -FFFFFFFF80000000 CF000000_00 -1000001FFDFFFFFF 5D800001_01 -0000000000003B5B 466D6C00_00 -FFFFFFFFC0000000 CE800000_00 -FFFFFFBFFE0FFFFF D28003E0_01 -FFFFFFFFFFFFFFF0 C1800000_00 -FFFFFFFFE0000000 CE000000_00 -FFFFFFFBF00007FF D081FFFF_01 -01E986274F48EAAD 5BF4C314_01 -FFFFFFFFF0000000 CD800000_00 -1FFFFFFDFFFFFF7F 5E000000_01 -FFFFFFFFFFFFCB5A C6529800_00 -FFFFFFFFF8000000 CD000000_00 -7FF000000000FFFF 5EFFE000_01 -00000003C2717FC3 50709C60_01 -FFFFFFFFFC000000 CC800000_00 -FFFFFFE00008001F D1FFFFC0_01 -FFFFFFFFFFEFABDA C982A130_00 -FFFFFFFFFE000000 CC000000_00 -0200000000000002 5C000000_01 -FFFFFFFFF8FDA53F CCE04B58_01 -FFFFFFFFFF000000 CB800000_00 -F6000003FFFFFFFE DD200000_01 -FFFFFFFFFFFFFFD0 C2400000_00 -FFFFFFFFFF800000 CB000000_00 -FFFFFFFFFFBFFF7E CA800104_00 -00000000EE0FEA62 4F6E0FEA_01 -FFFFFFFFFFC00000 CA800000_00 -0000007FFF9FFFFD 52FFFF40_01 -00000037F35EDC1D 525FCD7B_01 -FFFFFFFFFFE00000 CA000000_00 -FFFFFFF7FDFFFF7D D1002000_01 -00000000000001AD 43D68000_00 -FFFFFFFFFFF00000 C9800000_00 -FFFFFF0000100020 D37FFFF0_01 -27F167FBC7FC5F9A 5E1FC5A0_01 -FFFFFFFFFFF80000 C9000000_00 -003FFFFFFFFC0001 5A800000_01 -000E48F9F4EBD30E 59648F9F_01 -FFFFFFFFFFFC0000 C8800000_00 -DFFFFFFFFFFBFFFE DE000000_01 -FC91C23EE8C9424F DC5B8F70_01 -FFFFFFFFFFFE0000 C8000000_00 -F7DFFBFFFFFFFFFE DD020040_01 -000000002CAE080C 4E32B820_01 -FFFFFFFFFFFF0000 C7800000_00 -FFFFC00010000020 D67FFFC0_01 -04D921F917B20E40 5C9B243F_01 -FFFFFFFFFFFF8000 C7000000_00 -F8000FFFFFFFFFFD DCFFFE00_01 -FFF17C566BC7D811 D9683A99_01 -FFFFFFFFFFFFC000 C6800000_00 -00000000000000FE 437E0000_00 -FFF82AC14930D386 D8FAA7D7_01 -FFFFFFFFFFFFE000 C6000000_00 -00000000000003FC 447F0000_00 -000E62EC60E119FC 59662EC6_01 -FFFFFFFFFFFFF000 C5800000_00 -FFFFEFF7FF7FFFFE D5804004_01 -0E2B1ECF210EEDC5 5D62B1ED_01 -FFFFFFFFFFFFF800 C5000000_00 -00000000007FFF1F 4AFFFE3E_00 -FFFFFE534F5676F7 D3D65855_01 -FFFFFFFFFFFFFC00 C4800000_00 -0000001004FFFFFD 51802800_01 -0000035C939669F1 545724E6_01 -FFFFFFFFFFFFFE00 C4000000_00 -1FFFFFFFFFFFFDFD 5E000000_01 -FFFFFFFFFFFFFF91 C2DE0000_00 -FFFFFFFFFFFFFF00 C3800000_00 -01FFFFFFFBFFEFFE 5C000000_01 -000000000000016E 43B70000_00 -FFFFFFFFFFFFFF80 C3000000_00 -FFF7FFFFFFFFF7FD D9000000_01 -FFFFF8E2BCFAC553 D4E3A861_01 -FFFFFFFFFFFFFFC0 C2800000_00 -FFFFFBFFFFFE0FFE D4800000_01 -00000001A4E704BF 4FD27382_01 -FFFFFFFFFFFFFFE0 C2000000_00 -1400007FFFFFFFFD 5DA00004_01 -FFFFFFFC93B187B4 D05B139E_01 -FFFFFFFFFFFFFFF0 C1800000_00 -40000000007FFFFD 5E800000_01 -000000000067D468 4ACFA8D0_00 -FFFFFFFFFFFFFFF8 C1000000_00 -007FFEFFFFFBFFFE 5AFFFE00_01 -FFFFFFE26CEC79F8 D1EC989C_01 -FFFFFFFFFFFFFFFC C0800000_00 -00FFFFFF000000FF 5B7FFFFF_01 -FFFFFFFFE0D3983A CDF9633E_01 -FFFFFFFFFFFFFFFE C0000000_00 -00007FFFBFFF7FFE 56FFFF80_01 -FFFFFFFDF4A7088A D002D63E_01 -FFFFFFFFFFFFFFFF BF800000_00 -000008000000027E 55000000_01 -000000000000F4E8 4774E800_00 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFF83FFDF CAF80042_00 -00000E11407887B2 55611408_01 -FFFFFFFFFFFFFFFB C0A00000_00 -04000003FFFFFFF6 5C800000_01 -0000000000000513 44A26000_00 -FFFFFFFFFFFFFFF7 C1100000_00 -BFFC00000000003E DE800800_01 -00000008D7BBB75B 510D7BBB_01 -FFFFFFFFFFFFFFEF C1880000_00 -000FFFFBFFFC0000 597FFFC0_01 -FFFFFFFFFFCD5A23 CA4A9774_00 -FFFFFFFFFFFFFFDF C2040000_00 -FFBFDFFFBFFFFFFF DA804001_01 -000000000000007F 42FE0000_00 -FFFFFFFFFFFFFFBF C2820000_00 -00000007FF800003 50FFF000_01 -000000000002BB02 482EC080_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEE7FF C78C0080_00 -00264B2B9BAD0DA2 5A192CAE_01 -FFFFFFFFFFFFFEFF C3808000_00 -0000000000100803 49804018_00 -FF9B1DCB9F857D5E DAC9C469_01 -FFFFFFFFFFFFFDFF C4004000_00 -FFFFFFBFFFFFEFEE D2800000_01 -F6FD7542899C1C6F DD1028AC_01 -FFFFFFFFFFFFFBFF C4802000_00 -FF800000004001FF DB000000_01 -0000000002BE4932 4C2F924C_01 -FFFFFFFFFFFFF7FF C5001000_00 -00001004000FFFFE 55802000_01 -FFFFFF9DAA0123E0 D2C4ABFE_01 -FFFFFFFFFFFFEFFF C5800800_00 -00000001FDFFFDFE 4FFEFFFF_01 -FFFC1C8703B1DCB0 D878DE3F_01 -FFFFFFFFFFFFDFFF C6000400_00 -FE0FE00000000000 DBF81000_00 -0779ED944A4E2779 5CEF3DB3_01 -FFFFFFFFFFFFBFFF C6800200_00 -FBFFFE0400000000 DC800040_01 -0000010127E03666 538093F0_01 -FFFFFFFFFFFF7FFF C7000100_00 -FFFFF0200000FFFE D57E0000_01 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEFFFF C7800080_00 -FFEFFE0000080000 D9801000_01 -FFFFFFFFFD3354EA CC332AC6_01 -FFFFFFFFFFFDFFFF C8000040_00 -003FF0000003FFFE 5A7FC000_01 -0000006375B23F7B 52C6EB64_01 -FFFFFFFFFFFBFFFF C8800020_00 -000407FFFFFFFFF6 58810000_01 -0000000092117F38 4F12117F_01 -FFFFFFFFFFF7FFFF C9000010_00 -FFFFFFFFFFFF7FFF C7000100_00 -00000000000008BE 450BE000_00 -FFFFFFFFFFEFFFFF C9800008_00 -004000020FFFFFFF 5A800004_01 -FFFFB84C2D8BC9CB D68F67A5_01 -FFFFFFFFFFDFFFFF CA000004_00 -00FFFFFFFFFFFFFD 5B800000_01 -00000023C2C6F284 520F0B1C_01 -FFFFFFFFFFBFFFFF CA800002_00 -FFFDDFFFFFFFFFFD D8080000_01 -00000000746356C4 4EE8C6AE_01 -FFFFFFFFFF7FFFFF CB000001_00 -010000000000BFFF 5B800000_01 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFEFFFFFF CB800000_01 -FFFFBF7FFBFFFFFE D6810008_01 -00000006386CE889 50C70D9D_01 -FFFFFFFFFDFFFFFF CC000000_01 -F00000F7FFFFFFFF DD7FFFF1_01 -FFFDFC53090C46A4 D800EB3E_01 -FFFFFFFFFBFFFFFF CC800000_01 -0000000000800047 4B000047_00 -FFFFFFFFD693872E CE25B1E3_01 -FFFFFFFFF7FFFFFF CD000000_01 -000000007FBFFBFF 4EFF7FF8_01 -00000026A7845E35 521A9E11_01 -FFFFFFFFEFFFFFFF CD800000_01 -FFFFFFDFFFFFFBFD D2000000_01 -000000001433D14C 4DA19E8A_01 -FFFFFFFFDFFFFFFF CE000000_01 -0001FFFFFFE0000E 58000000_01 -F0F23E8068D3D84A DD70DC18_01 -FFFFFFFFBFFFFFFF CE800000_01 -F7FFBFFFFFFFBFFF DD000400_01 -FFFFBD29B7459087 D685AC91_01 -FFFFFFFF7FFFFFFF CF000000_01 -FFFFFFF8FFFFBFFF D0E00008_01 -FFFFFFFFFFEDDC06 C9911FD0_00 -FFFFFFFEFFFFFFFF CF800000_01 -FFFFFFF80001FFFF D0FFFFC0_01 -0000000000002FF9 463FE400_00 -FFFFFFFDFFFFFFFF D0000000_01 -004000040000FFFF 5A800008_01 -FFFFFFFFFFFFFFF1 C1700000_00 -FFFFFFFBFFFFFFFF D0800000_01 -C0000000007FFFFA DE800000_01 -FFFFFFFFFE053E2B CBFD60EA_01 -FFFFFFF7FFFFFFFF D1000000_01 -7FFE000007FFFFFF 5EFFFC00_01 -000000000000000D 41500000_00 -FFFFFFEFFFFFFFFF D1800000_01 -F80000000001007E DD000000_01 -FFFFED48424AD9D6 D595BDEE_01 -FFFFFFDFFFFFFFFF D2000000_01 -FFFFFE0001FEFFFF D3FFFF01_01 -000000000000013B 439D8000_00 -FFFFFFBFFFFFFFFF D2800000_01 -0007FBFFFFFDFFFE 58FF8000_01 -4A16BD4128090C83 5E942D7B_01 -FFFFFF7FFFFFFFFF D3000000_01 -00FFF7FFFF7FFFFE 5B7FF800_01 -0000000000000006 40C00000_00 -FFFFFEFFFFFFFFFF D3800000_01 -FBFFFFBFFFBFFFFF DC800008_01 -00000000000001BA 43DD0000_00 -FFFFFDFFFFFFFFFF D4000000_01 -0000000040000082 4E800001_01 -FF07A2BF5B689F89 DB785D41_01 -FFFFFBFFFFFFFFFF D4800000_01 -0000001FF8000008 51FFC000_01 -F87CAA7DE672DE8B DCF06AB0_01 -FFFFF7FFFFFFFFFF D5000000_01 -07FFF80000000002 5CFFFF00_01 -0000000010A1E5B8 4D850F2E_01 -FFFFEFFFFFFFFFFF D5800000_01 -F7FFFFE00007FFFF DD000002_01 -FFFFFFFFFFF6ADFC C9152040_00 -FFFFDFFFFFFFFFFF D6000000_01 -FFFFFF03FFFFFFC0 D37C0000_01 -EA579475948F0032 DDAD435C_01 -FFFFBFFFFFFFFFFF D6800000_01 -FC00000000003FF6 DC800000_01 -002E677AC313BF60 5A399DEB_01 -FFFF7FFFFFFFFFFF D7000000_01 -02000007FF7FFFFF 5C000002_01 -0000000E999639F1 51699964_01 -FFFEFFFFFFFFFFFF D7800000_01 -FFFF83FFFFFFFFBE D6F80000_01 -000000000001537D 47A9BE80_00 -FFFDFFFFFFFFFFFF D8000000_01 -EFFFFFC00000003D DD800002_01 -FFFFFFF21FEDFD35 D15E0120_01 -FFFBFFFFFFFFFFFF D8800000_01 -FFFFFFF0000007FE D1800000_01 -FFFFFFFFFFDE0839 CA07DF1C_00 -FFF7FFFFFFFFFFFF D9000000_01 -0000007FFFE000FF 52FFFFC0_01 -FFFFFFFF79F30F48 CF060CF1_01 -FFEFFFFFFFFFFFFF D9800000_01 -FFFFFC13FFFFFFFD D47B0000_01 -0000000000001B85 45DC2800_00 -FFDFFFFFFFFFFFFF DA000000_01 -000008000007FFFE 55000000_01 -12DB4409E5AE87E6 5D96DA20_01 -FFBFFFFFFFFFFFFF DA800000_01 -FFFFFFFFFFF7BFEE C9040120_00 -FFFFFFFFFFFFFFFD C0400000_00 -FF7FFFFFFFFFFFFF DB000000_01 -000000001040FFFE 4D820800_01 -00000909A09C13D3 55109A0A_01 -FEFFFFFFFFFFFFFF DB800000_01 -FFFFFF01FFFFFF7F D37E0000_01 -FFFFFF72E7D2575D D30D182E_01 -FDFFFFFFFFFFFFFF DC000000_01 -FFFFFFFFFFFEFFDB C7801280_00 -0000000000000017 41B80000_00 -FBFFFFFFFFFFFFFF DC800000_01 -100000001FFFFFF6 5D800000_01 -000000114B12EF51 518A5897_01 -F7FFFFFFFFFFFFFF DD000000_01 -0407FFFFFFFFFEFF 5C810000_01 -FFFFFF769F3A5C2C D30960C6_01 -EFFFFFFFFFFFFFFF DD800000_01 -FFFFFFFDF7FFFFFD D0020000_01 -FFFFFFFFFFFFFFF2 C1600000_00 -DFFFFFFFFFFFFFFF DE000000_01 -FFFFFFFFFE0007FF CBFFFC00_01 -000000000000001E 41F00000_00 -BFFFFFFFFFFFFFFF DE800000_01 -FFF800000009FFFF D9000000_01 -0000000000007AA4 46F54800_00 -7FFFFFFFFFFFFFFF 5F000000_01 -4080000000FFFFFF 5E810000_01 -000000000DE7601D 4D5E7602_01 -3FFFFFFFFFFFFFFF 5E800000_01 -FFCFFFFFFFBFFFFE DA400000_01 -FFFFFFFFFFFFFFCA C2580000_00 -1FFFFFFFFFFFFFFF 5E000000_01 -000080400000003F 57004000_01 -00000000001F75A5 49FBAD28_00 -0FFFFFFFFFFFFFFF 5D800000_01 -FFFFFFEFFFFFCFFE D1800002_01 -FFFFFEE775887420 D38C453C_01 -07FFFFFFFFFFFFFF 5D000000_01 -00000000000801FE 49001FE0_00 -0000000000213FF1 4A04FFC4_00 -03FFFFFFFFFFFFFF 5C800000_01 -07FEFFFFFFFFFFEE 5CFFE000_01 -0000000000000004 40800000_00 -01FFFFFFFFFFFFFF 5C000000_01 -0000000820000003 51020000_01 -FFFFFFF9AD105214 D0CA5DF6_01 -00FFFFFFFFFFFFFF 5B800000_01 -FFFFF00FFFFFFFBE D57F0000_01 -FFFFFFFFFFCC48E7 CA4EDC64_00 -007FFFFFFFFFFFFF 5B000000_01 -00000FFFEF7FFFFF 557FFEF8_01 -FFFFFFFFFF0BA6CB CB745935_00 -003FFFFFFFFFFFFF 5A800000_01 -FFFFFF7FBFFFFFBF D3004000_01 -FFFFFFFFFFF24425 C95BBDB0_00 -001FFFFFFFFFFFFF 5A000000_01 -200000001FFBFFFF 5E000000_01 -FFFFFF4E7115EC53 D3318EEA_01 -000FFFFFFFFFFFFF 59800000_01 -FFFFF803FFFFFFBF D4FF8000_01 -FFFFFC2E539ADCFE D4746B19_01 -0007FFFFFFFFFFFF 59000000_01 -FFFFFFFFFBFFFFFF CC800000_01 -00000055084732F3 52AA108E_01 -0003FFFFFFFFFFFF 58800000_01 -BFFF7FFFFFFFFE00 DE800100_01 -FFFFFFFFFFFF8543 C6F57A00_00 -0001FFFFFFFFFFFF 58000000_01 -0000001FFBFFE000 51FFDFFF_00 -FFFFFFFFFFFE491B C7DB7280_00 -0000FFFFFFFFFFFF 57800000_01 -FC00200000001FFE DC7FF800_01 -FFFFF16898822A24 D5697678_01 -00007FFFFFFFFFFF 57000000_01 -3FFF03FFFFFFFFFE 5E7FFC10_01 -FFFFFF8FFE18C7BF D2E003CE_01 -00003FFFFFFFFFFF 56800000_01 -FFFFFEFFFEFFFFFD D3800080_01 -00F03620C1266ED9 5B703621_01 -00001FFFFFFFFFFF 56000000_01 -BF7EFFFFFFFFFFFF DE810200_01 -FFFFFFFFFFFFFFD5 C22C0000_00 -00000FFFFFFFFFFF 55800000_01 -FFFBFFFFF803FFFE D8800001_01 -0000000000068684 48D0D080_00 -000007FFFFFFFFFF 55000000_01 -DFFFFFE00000001E DE000000_01 -FFFFFFFFFFFFECF5 C5985800_00 -000003FFFFFFFFFF 54800000_01 -FFFF00400000FFFF D77FC000_01 -0000000000000002 40000000_00 -000001FFFFFFFFFF 54000000_01 -FBFFFFFFFFFFBDFE DC800000_01 -0000000000000BC9 453C9000_00 -000000FFFFFFFFFF 53800000_01 -807FFFFFFFFFDFFE DEFF0000_01 -FFC274E35A70CD76 DA762C73_01 -0000007FFFFFFFFF 53000000_01 -0FFFFFFFFEFFFFFD 5D800000_01 -FFFFFFFF00E73AFC CF7F18C5_01 -0000003FFFFFFFFF 52800000_01 -FFC000000001000E DA800000_01 -FFFFFFFFFFFE15E9 C7F50B80_00 -0000001FFFFFFFFF 52000000_01 -0001FFFFFFFFF3FD 58000000_01 -0000000000000033 424C0000_00 -0000000FFFFFFFFF 51800000_01 -000000001FFFBFFF 4DFFFE00_01 -FFFFFFEE6B141E1B D18CA75F_01 -00000007FFFFFFFF 51000000_01 -FFFFFFFFF60007FF CD1FFF80_01 -00000001AB310BA6 4FD59886_01 -00000003FFFFFFFF 50800000_01 -0003FFFFB7FFFFFF 587FFFEE_01 -FFFFFFFFFFFFF195 C566B000_00 -00000001FFFFFFFF 50000000_01 -FFFFFFFF8000000B CF000000_01 -00000019BA8D5559 51CDD46B_01 -00000000FFFFFFFF 4F800000_01 -FBFEFFFFFFFFFFF9 DC802000_01 -FFFFFFB6F062822D D2921F3B_01 -000000007FFFFFFF 4F000000_01 -0001000000000082 57800000_01 -01CEAD9E2FB104A4 5BE756CF_01 -000000003FFFFFFF 4E800000_01 -000003FFFFFFFF7C 54800000_01 -FFFFFFFFFD681E78 CC25F862_00 -000000001FFFFFFF 4E000000_01 -00002000400001FF 56000100_01 -0000000000000018 41C00000_00 -000000000FFFFFFF 4D800000_01 -3FFF80000000003E 5E7FFE00_01 -FFFFFFFFFFFFFF95 C2D60000_00 -0000000007FFFFFF 4D000000_01 -010000BFFFFFFFFF 5B800060_01 -0000001697087B19 51B4B844_01 -0000000003FFFFFF 4C800000_01 -FBFFFFFFFFEEFFFD DC800000_01 -0000000E64BDFC55 51664BE0_01 -0000000001FFFFFF 4C000000_01 -FC00000001FFFFFE DC800000_01 -FFFED156A62AB849 D79754AD_01 -0000000000FFFFFF 4B7FFFFF_00 -FFFFFFF83FEFFFFD D0F80200_01 -00015354EAE7C259 57A9AA75_01 -00000000007FFFFF 4AFFFFFE_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFF0F4DF3C75 D170B20C_01 -00000000003FFFFF 4A7FFFFC_00 -FFFA000000001FFF D8C00000_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000001FFFFF 49FFFFF8_00 -FFFFFFFFFF7FFE40 CB0001C0_00 -FFFFFFDB5433CB9B D212AF31_01 -00000000000FFFFF 497FFFF0_00 -FFFFFDFFDFFDFFFD D4000801_01 -FFFFFFFFFFDEAE1F CA054784_00 -000000000007FFFF 48FFFFE0_00 -FFFFFFFFF0080006 CD7F8000_01 -FFFFFFFE7735DEC7 CFC46511_01 -000000000003FFFF 487FFFC0_00 -00000001FBFFFFFF 4FFE0000_01 -000003757D8B12ED 545D5F63_01 -000000000001FFFF 47FFFF80_00 -FFFFFE07F7FFFFFF D3FC0400_01 -00000A654064E046 55265406_01 -000000000000FFFF 477FFF00_00 -08000000000017FF 5D000000_01 -FFFFFFFFFFFFFFE7 C1C80000_00 -0000000000007FFF 46FFFE00_00 -07FFFFFFFFFFFDF6 5D000000_01 -FFFFAD78B3D6C3B6 D6A50E98_01 -0000000000003FFF 467FFC00_00 -0000300004000000 56400010_00 -FFFFFFF70B77F34F D10F4881_01 -0000000000001FFF 45FFF800_00 -FFFFFF80006FFFFE D2FFFF20_01 -0000013EB4D67EC8 539F5A6B_01 -0000000000000FFF 457FF000_00 -BFFFDFFFFBFFFFFF DE800040_01 -0005CEAF34EA1DC7 58B9D5E7_01 -00000000000007FF 44FFE000_00 -00004800007FFFFD 56900001_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000000003FF 447FC000_00 -0000000200001000 50000004_00 -00000000000360D0 48583400_00 -00000000000001FF 43FF8000_00 -01003FFFFFFFFFFC 5B802000_01 -00C000708FF1BA51 5B400071_01 -00000000000000FF 437F0000_00 -F802000003FFFFFF DCFFC000_01 -0F9E07DCC0BDC061 5D79E07E_01 -000000000000007F 42FE0000_00 -03FF0000000000FF 5C7FC000_01 -FFFFFFE1B9B2A079 D1F2326B_01 -000000000000003F 427C0000_00 -FFF80000000080FF D9000000_01 -00000000001EB5B4 49F5ADA0_00 -000000000000001F 41F80000_00 -000000000077FBFE 4AEFF7FC_00 -00000000005AC607 4AB58C0E_00 -000000000000000F 41700000_00 -FFFFFFFEF80000FF CF840000_01 -000005C5B9D66984 54B8B73B_01 -0000000000000007 40E00000_00 -C001FFFFFFF00000 DE7FF800_01 -00001D06B372AA06 55E8359C_01 -0000000000000003 40400000_00 +07FFFDFFFFFFFF7F_5CFFFFC0_01 +0000000032CC8B7A_4E4B322E_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_CE7FFF00_01 +032C857F319EDE38_5C4B2160_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_D4800001_01 +00394C79B6D3007B_5A6531E7_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_DC800002_01 +0000000001AE458D_4BD722C6_01 +0000000000000004_40800000_00 +00040008000007FE_58800100_01 +F9EB456140D88764_DCC29754_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_D5DFF800_01 +07DE834A248EDF36_5CFBD069_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC008_01 +FFFFFFFFFFE385E2_C9E3D0F0_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_DD7FBE00_01 +000000059EB1FD45_50B3D640_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_C84001C0_00 +FFFFFFFFFFFEDDFE_C7910100_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000000C89FF56B_4F489FF5_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF8_01 +1B5E4F0BE0DEBFF0_5DDAF278_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_D801FF00_01 +FFFFFFFFFFF4766B_C9389950_00 +0000000000000400_44800000_00 +0000080100000FFE_55001000_01 +000000000000000C_41400000_00 +0000000000000800_45000000_00 +0048000000100000_5A900000_01 +FFE662A109109D0A_D9CCEAF8_01 +0000000000001000_45800000_00 +C000000037FFFFFE_DE800000_01 +FFFFFFFFFFFFFFE4_C1E00000_00 +0000000000002000_46000000_00 +F801000000100000_DCFFE000_01 +FE114B79075F70EE_DBF75A43_01 +0000000000004000_46800000_00 +100000000001003E_5D800000_01 +00000000000003AC_446B0000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000004_01 +00000044A3A3DBE5_52894748_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_D9FFFE08_01 +FFFFFFFFFFFF1A91_C7656F00_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_D503C000_01 +0000000000003309_464C2400_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF8_01 +FFFFFFFFFFFFFF58_C3280000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_D207F800_01 +0000000000002980_46260000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF080_01 +000000000000005D_42BA0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF80_01 +FFFC8C23DA2CEAD8_D85CF709_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_DE000000_01 +FFFFFDE3C1DEC43C_D4070F88_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_D77FFFF4_01 +000000000030FFBE_4A43FEF8_00 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_D7FFFFFC_01 +FFFFFFFFEFDEED86_CD810894_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_DD400000_01 +000000001DA3FF45_4DED1FFA_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_CF7FFF00_01 +FFFFFFFE9B1BCB54_CFB2721A_01 +0000000008000000_4D000000_00 +00004000004001FE_56800001_01 +F27DD19DE6563714_DD5822E6_01 +0000000010000000_4D800000_00 +FFC00000004007FE_DA800000_01 +000000000001A359_47D1AC80_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C700040_01 +FFFFFFFFFE62EC20_CBCE89F0_00 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E800000_01 +000000000000285F_46217C00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_CE800020_01 +FFFFF836F99DBAA8_D4F920CC_01 +0000000100000000_4F800000_00 +00000020003FFEFE_52000100_01 +0033466832042D47_5A4D19A1_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_C4EF2000_00 +00000000003829C8_4A60A720_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_55800000_01 +0000000FB77C672B_517B77C6_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D000400_01 +0000000000001B78_45DBC000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_DB000000_01 +0000000000000071_42E20000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_55A00000_01 +FFFFFFFFFFFFFF86_C2F40000_00 +0000004000000000_52800000_00 +0800000000040800_5D000000_01 +FFF8A60D9E19F17E_D8EB3E4C_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +FFFFFFFFF7506DBA_CD0AF924_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_C7820480_00 +FFFFFFFFFEA42AC9_CBADEA9C_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_55840000_01 +FFE7AA3F2BDACC89_D9C2AE07_01 +0000040000000000_54800000_00 +FFF8040000040000_D8FF8000_01 +FFFFFFFFFFFFFFFD_C0400000_00 +0000080000000000_55000000_00 +FFFF80000800001F_D6FFFFF0_01 +FFFDF681DECDADC9_D8025F88_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_D3800010_01 +FFFFFFFFFFFFCFBE_C6410800_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51102000_01 +FEC01FECA24DE1B0_DB9FF00A_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_DD000000_01 +F858A66761669936_DCF4EB33_01 +0000800000000000_57000000_00 +FFFEFF800000003E_D7804000_01 +F716EA43FAC45C97_DD0E915C_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_C2680000_00 +0024D70EC7661FD8_5A135C3B_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_DE7E0000_01 +FFD956DBD0AEE817_DA1AA491_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FC_01 +FFFFFFFFFFFF4300_C73D0000_00 +0008000000000000_59000000_00 +4000000004002000_5E800000_01 +C12EDF40F41F6021_DE7B4483_01 +0010000000000000_59800000_00 +FF9000000000001D_DAE00000_01 +FFFFFFF83DE950F6_D0F842D6_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_DEFFFFF8_01 +FE2B59CB3A604D69_DBEA531A_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5F000000_01 +000000A37C210862_53237C21_01 +0080000000000000_5B000000_00 +0002000002000002_58000001_01 +FFFFB65CD8617789_D693464F_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55E00000_01 +FFFFFFFFFFFFF01D_C57E3000_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800004_01 +000000000D098D19_4D5098D2_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C800000_01 +000006B3BD2C7BEF_54D677A6_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFF00_01 +FFFF4E5ADDDAA4A8_D731A522_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE00_01 +FFFFFFFFFFFFFF21_C35F0000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83C000_01 +FFFFFFFFFC648262_CC66DF68_01 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_DE7FFF80_01 +FFFFFF7353AC45D2_D30CAC54_01 +8000000000000000_DF000000_00 +FFFFFFFFFFE7EFFF_C9C08008_00 +0000000000A1202D_4B21202D_00 +C000000000000000_DE800000_00 +FFFFFFFFFFFF5F7F_C7208100_00 +000000000040CA70_4A8194E0_00 +E000000000000000_DE000000_00 +0000200201FFFFFE_56000808_01 +00000003B55D87D4_506D5762_01 +F000000000000000_DD800000_00 +FF80000DFFFFFFFF_DAFFFFE4_01 +000000010510FAEF_4F82887D_01 +F800000000000000_DD000000_00 +0003FFF00000000F_587FFC00_01 +000000000000724A_46E49400_00 +FC00000000000000_DC800000_00 +FFFFFFDF80000002_D2020000_01 +0000000000000064_42C80000_00 +FE00000000000000_DC000000_00 +FEFFFFFFFFF800FE_DB800000_01 +FFFFFFC2C6222702_D274E777_01 +FF00000000000000_DB800000_00 +0000000408000002_50810000_01 +000000E96DF1CB41_53696DF2_01 +FF80000000000000_DB000000_00 +007FFFFFFFFFF9FE_5B000000_01 +F727F174DEE7DC85_DD0D80E9_01 +FFC0000000000000_DA800000_00 +8000000003FFFEFE_DF000000_01 +FFFFFFFFFFF0BD5B_C9742A50_00 +FFE0000000000000_DA000000_00 +0BEFFFFFFFFFFFFF_5D3F0000_01 +000000000002790C_481E4300_00 +FFF0000000000000_D9800000_00 +FFFFFFFFFFEFFBFA_C9802030_00 +000000169E75DF01_51B4F3AF_01 +FFF8000000000000_D9000000_00 +00000007FEFFDFFF_50FFDFFC_01 +000000000000000E_41600000_00 +FFFC000000000000_D8800000_00 +0003FFFE0007FFFE_587FFF80_01 +FFFFFFFFFFF28622_C9579DE0_00 +FFFE000000000000_D8000000_00 +FFFFFF7FFFFDF7FF_D3000002_01 +00072F0EC496FE21_58E5E1D9_01 +FFFF000000000000_D7800000_00 +DFBFFFFFFFFFFFFE_DE010000_01 +0000000000FC1FCA_4B7C1FCA_00 +FFFF800000000000_D7000000_00 +00000FFF800FFFFE_557FF801_01 +FFFF5194E4A9C2CE_D72E6B1B_01 +FFFFC00000000000_D6800000_00 +00000002100007FD_50040002_01 +FFFFFFFFFFC2D8FE_CA749C08_00 +FFFFE00000000000_D6000000_00 +000000000007FF6E_48FFEDC0_00 +000000000001766E_47BB3700_00 +FFFFF00000000000_D5800000_00 +0040000400000002_5A800008_01 +0000000000007841_46F08200_00 +FFFFF80000000000_D5000000_00 +3DFFFFFFFFFFFF7E_5E780000_01 +FFFFFFE549E17E30_D1D5B0F4_01 +FFFFFC0000000000_D4800000_00 +FFFFFFFFFFFFFEE1_C38F8000_00 +FFFFFFFFFFFFFFE7_C1C80000_00 +FFFFFE0000000000_D4000000_00 +000000000EFFFFDF_4D6FFFFE_01 +FFFFFFFFFFFFFF73_C30D0000_00 +FFFFFF0000000000_D3800000_00 +FD00000008000000_DC400000_01 +000000000001DBB1_47EDD880_00 +FFFFFF8000000000_D3000000_00 +FFFFFFFFFFF8007F_C8FFF020_00 +FFFFFFFEFD10A515_CF8177AD_01 +FFFFFFC000000000_D2800000_00 +FFEFFFFFFFFFFFFE_D9800000_01 +FAB02984F6283B6C_DCA9FACF_01 +FFFFFFE000000000_D2000000_00 +FFFFFFBC000001FE_D2880000_01 +FEB087C6B9FE7FE0_DBA7BC1D_01 +FFFFFFF000000000_D1800000_00 +FFF80001000007FE_D8FFFFE0_01 +00F2762EA6837956_5B72762F_01 +FFFFFFF800000000_D1000000_00 +FFF7E0FFFFFFFFFE_D901F000_01 +00002E1175484626_563845D5_01 +FFFFFFFC00000000_D0800000_00 +0000200020000FFE_56000080_01 +000000000000068F_44D1E000_00 +FFFFFFFE00000000_D0000000_00 +021FFFFFFFFBFFFF_5C080000_01 +FFFFFFFFFFFFFFF9_C0E00000_00 +FFFFFFFF00000000_CF800000_00 +FFFFFFD0000FFFFD_D23FFFC0_01 +000000BDF6658B83_533DF666_01 +FFFFFFFF80000000_CF000000_00 +1000001FFDFFFFFF_5D800001_01 +0000000000003B5B_466D6C00_00 +FFFFFFFFC0000000_CE800000_00 +FFFFFFBFFE0FFFFF_D28003E0_01 +FFFFFFFFFFFFFFF0_C1800000_00 +FFFFFFFFE0000000_CE000000_00 +FFFFFFFBF00007FF_D081FFFF_01 +01E986274F48EAAD_5BF4C314_01 +FFFFFFFFF0000000_CD800000_00 +1FFFFFFDFFFFFF7F_5E000000_01 +FFFFFFFFFFFFCB5A_C6529800_00 +FFFFFFFFF8000000_CD000000_00 +7FF000000000FFFF_5EFFE000_01 +00000003C2717FC3_50709C60_01 +FFFFFFFFFC000000_CC800000_00 +FFFFFFE00008001F_D1FFFFC0_01 +FFFFFFFFFFEFABDA_C982A130_00 +FFFFFFFFFE000000_CC000000_00 +0200000000000002_5C000000_01 +FFFFFFFFF8FDA53F_CCE04B58_01 +FFFFFFFFFF000000_CB800000_00 +F6000003FFFFFFFE_DD200000_01 +FFFFFFFFFFFFFFD0_C2400000_00 +FFFFFFFFFF800000_CB000000_00 +FFFFFFFFFFBFFF7E_CA800104_00 +00000000EE0FEA62_4F6E0FEA_01 +FFFFFFFFFFC00000_CA800000_00 +0000007FFF9FFFFD_52FFFF40_01 +00000037F35EDC1D_525FCD7B_01 +FFFFFFFFFFE00000_CA000000_00 +FFFFFFF7FDFFFF7D_D1002000_01 +00000000000001AD_43D68000_00 +FFFFFFFFFFF00000_C9800000_00 +FFFFFF0000100020_D37FFFF0_01 +27F167FBC7FC5F9A_5E1FC5A0_01 +FFFFFFFFFFF80000_C9000000_00 +003FFFFFFFFC0001_5A800000_01 +000E48F9F4EBD30E_59648F9F_01 +FFFFFFFFFFFC0000_C8800000_00 +DFFFFFFFFFFBFFFE_DE000000_01 +FC91C23EE8C9424F_DC5B8F70_01 +FFFFFFFFFFFE0000_C8000000_00 +F7DFFBFFFFFFFFFE_DD020040_01 +000000002CAE080C_4E32B820_01 +FFFFFFFFFFFF0000_C7800000_00 +FFFFC00010000020_D67FFFC0_01 +04D921F917B20E40_5C9B243F_01 +FFFFFFFFFFFF8000_C7000000_00 +F8000FFFFFFFFFFD_DCFFFE00_01 +FFF17C566BC7D811_D9683A99_01 +FFFFFFFFFFFFC000_C6800000_00 +00000000000000FE_437E0000_00 +FFF82AC14930D386_D8FAA7D7_01 +FFFFFFFFFFFFE000_C6000000_00 +00000000000003FC_447F0000_00 +000E62EC60E119FC_59662EC6_01 +FFFFFFFFFFFFF000_C5800000_00 +FFFFEFF7FF7FFFFE_D5804004_01 +0E2B1ECF210EEDC5_5D62B1ED_01 +FFFFFFFFFFFFF800_C5000000_00 +00000000007FFF1F_4AFFFE3E_00 +FFFFFE534F5676F7_D3D65855_01 +FFFFFFFFFFFFFC00_C4800000_00 +0000001004FFFFFD_51802800_01 +0000035C939669F1_545724E6_01 +FFFFFFFFFFFFFE00_C4000000_00 +1FFFFFFFFFFFFDFD_5E000000_01 +FFFFFFFFFFFFFF91_C2DE0000_00 +FFFFFFFFFFFFFF00_C3800000_00 +01FFFFFFFBFFEFFE_5C000000_01 +000000000000016E_43B70000_00 +FFFFFFFFFFFFFF80_C3000000_00 +FFF7FFFFFFFFF7FD_D9000000_01 +FFFFF8E2BCFAC553_D4E3A861_01 +FFFFFFFFFFFFFFC0_C2800000_00 +FFFFFBFFFFFE0FFE_D4800000_01 +00000001A4E704BF_4FD27382_01 +FFFFFFFFFFFFFFE0_C2000000_00 +1400007FFFFFFFFD_5DA00004_01 +FFFFFFFC93B187B4_D05B139E_01 +FFFFFFFFFFFFFFF0_C1800000_00 +40000000007FFFFD_5E800000_01 +000000000067D468_4ACFA8D0_00 +FFFFFFFFFFFFFFF8_C1000000_00 +007FFEFFFFFBFFFE_5AFFFE00_01 +FFFFFFE26CEC79F8_D1EC989C_01 +FFFFFFFFFFFFFFFC_C0800000_00 +00FFFFFF000000FF_5B7FFFFF_01 +FFFFFFFFE0D3983A_CDF9633E_01 +FFFFFFFFFFFFFFFE_C0000000_00 +00007FFFBFFF7FFE_56FFFF80_01 +FFFFFFFDF4A7088A_D002D63E_01 +FFFFFFFFFFFFFFFF_BF800000_00 +000008000000027E_55000000_01 +000000000000F4E8_4774E800_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFF83FFDF_CAF80042_00 +00000E11407887B2_55611408_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +04000003FFFFFFF6_5C800000_01 +0000000000000513_44A26000_00 +FFFFFFFFFFFFFFF7_C1100000_00 +BFFC00000000003E_DE800800_01 +00000008D7BBB75B_510D7BBB_01 +FFFFFFFFFFFFFFEF_C1880000_00 +000FFFFBFFFC0000_597FFFC0_01 +FFFFFFFFFFCD5A23_CA4A9774_00 +FFFFFFFFFFFFFFDF_C2040000_00 +FFBFDFFFBFFFFFFF_DA804001_01 +000000000000007F_42FE0000_00 +FFFFFFFFFFFFFFBF_C2820000_00 +00000007FF800003_50FFF000_01 +000000000002BB02_482EC080_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEE7FF_C78C0080_00 +00264B2B9BAD0DA2_5A192CAE_01 +FFFFFFFFFFFFFEFF_C3808000_00 +0000000000100803_49804018_00 +FF9B1DCB9F857D5E_DAC9C469_01 +FFFFFFFFFFFFFDFF_C4004000_00 +FFFFFFBFFFFFEFEE_D2800000_01 +F6FD7542899C1C6F_DD1028AC_01 +FFFFFFFFFFFFFBFF_C4802000_00 +FF800000004001FF_DB000000_01 +0000000002BE4932_4C2F924C_01 +FFFFFFFFFFFFF7FF_C5001000_00 +00001004000FFFFE_55802000_01 +FFFFFF9DAA0123E0_D2C4ABFE_01 +FFFFFFFFFFFFEFFF_C5800800_00 +00000001FDFFFDFE_4FFEFFFF_01 +FFFC1C8703B1DCB0_D878DE3F_01 +FFFFFFFFFFFFDFFF_C6000400_00 +FE0FE00000000000_DBF81000_00 +0779ED944A4E2779_5CEF3DB3_01 +FFFFFFFFFFFFBFFF_C6800200_00 +FBFFFE0400000000_DC800040_01 +0000010127E03666_538093F0_01 +FFFFFFFFFFFF7FFF_C7000100_00 +FFFFF0200000FFFE_D57E0000_01 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEFFFF_C7800080_00 +FFEFFE0000080000_D9801000_01 +FFFFFFFFFD3354EA_CC332AC6_01 +FFFFFFFFFFFDFFFF_C8000040_00 +003FF0000003FFFE_5A7FC000_01 +0000006375B23F7B_52C6EB64_01 +FFFFFFFFFFFBFFFF_C8800020_00 +000407FFFFFFFFF6_58810000_01 +0000000092117F38_4F12117F_01 +FFFFFFFFFFF7FFFF_C9000010_00 +FFFFFFFFFFFF7FFF_C7000100_00 +00000000000008BE_450BE000_00 +FFFFFFFFFFEFFFFF_C9800008_00 +004000020FFFFFFF_5A800004_01 +FFFFB84C2D8BC9CB_D68F67A5_01 +FFFFFFFFFFDFFFFF_CA000004_00 +00FFFFFFFFFFFFFD_5B800000_01 +00000023C2C6F284_520F0B1C_01 +FFFFFFFFFFBFFFFF_CA800002_00 +FFFDDFFFFFFFFFFD_D8080000_01 +00000000746356C4_4EE8C6AE_01 +FFFFFFFFFF7FFFFF_CB000001_00 +010000000000BFFF_5B800000_01 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFEFFFFFF_CB800000_01 +FFFFBF7FFBFFFFFE_D6810008_01 +00000006386CE889_50C70D9D_01 +FFFFFFFFFDFFFFFF_CC000000_01 +F00000F7FFFFFFFF_DD7FFFF1_01 +FFFDFC53090C46A4_D800EB3E_01 +FFFFFFFFFBFFFFFF_CC800000_01 +0000000000800047_4B000047_00 +FFFFFFFFD693872E_CE25B1E3_01 +FFFFFFFFF7FFFFFF_CD000000_01 +000000007FBFFBFF_4EFF7FF8_01 +00000026A7845E35_521A9E11_01 +FFFFFFFFEFFFFFFF_CD800000_01 +FFFFFFDFFFFFFBFD_D2000000_01 +000000001433D14C_4DA19E8A_01 +FFFFFFFFDFFFFFFF_CE000000_01 +0001FFFFFFE0000E_58000000_01 +F0F23E8068D3D84A_DD70DC18_01 +FFFFFFFFBFFFFFFF_CE800000_01 +F7FFBFFFFFFFBFFF_DD000400_01 +FFFFBD29B7459087_D685AC91_01 +FFFFFFFF7FFFFFFF_CF000000_01 +FFFFFFF8FFFFBFFF_D0E00008_01 +FFFFFFFFFFEDDC06_C9911FD0_00 +FFFFFFFEFFFFFFFF_CF800000_01 +FFFFFFF80001FFFF_D0FFFFC0_01 +0000000000002FF9_463FE400_00 +FFFFFFFDFFFFFFFF_D0000000_01 +004000040000FFFF_5A800008_01 +FFFFFFFFFFFFFFF1_C1700000_00 +FFFFFFFBFFFFFFFF_D0800000_01 +C0000000007FFFFA_DE800000_01 +FFFFFFFFFE053E2B_CBFD60EA_01 +FFFFFFF7FFFFFFFF_D1000000_01 +7FFE000007FFFFFF_5EFFFC00_01 +000000000000000D_41500000_00 +FFFFFFEFFFFFFFFF_D1800000_01 +F80000000001007E_DD000000_01 +FFFFED48424AD9D6_D595BDEE_01 +FFFFFFDFFFFFFFFF_D2000000_01 +FFFFFE0001FEFFFF_D3FFFF01_01 +000000000000013B_439D8000_00 +FFFFFFBFFFFFFFFF_D2800000_01 +0007FBFFFFFDFFFE_58FF8000_01 +4A16BD4128090C83_5E942D7B_01 +FFFFFF7FFFFFFFFF_D3000000_01 +00FFF7FFFF7FFFFE_5B7FF800_01 +0000000000000006_40C00000_00 +FFFFFEFFFFFFFFFF_D3800000_01 +FBFFFFBFFFBFFFFF_DC800008_01 +00000000000001BA_43DD0000_00 +FFFFFDFFFFFFFFFF_D4000000_01 +0000000040000082_4E800001_01 +FF07A2BF5B689F89_DB785D41_01 +FFFFFBFFFFFFFFFF_D4800000_01 +0000001FF8000008_51FFC000_01 +F87CAA7DE672DE8B_DCF06AB0_01 +FFFFF7FFFFFFFFFF_D5000000_01 +07FFF80000000002_5CFFFF00_01 +0000000010A1E5B8_4D850F2E_01 +FFFFEFFFFFFFFFFF_D5800000_01 +F7FFFFE00007FFFF_DD000002_01 +FFFFFFFFFFF6ADFC_C9152040_00 +FFFFDFFFFFFFFFFF_D6000000_01 +FFFFFF03FFFFFFC0_D37C0000_01 +EA579475948F0032_DDAD435C_01 +FFFFBFFFFFFFFFFF_D6800000_01 +FC00000000003FF6_DC800000_01 +002E677AC313BF60_5A399DEB_01 +FFFF7FFFFFFFFFFF_D7000000_01 +02000007FF7FFFFF_5C000002_01 +0000000E999639F1_51699964_01 +FFFEFFFFFFFFFFFF_D7800000_01 +FFFF83FFFFFFFFBE_D6F80000_01 +000000000001537D_47A9BE80_00 +FFFDFFFFFFFFFFFF_D8000000_01 +EFFFFFC00000003D_DD800002_01 +FFFFFFF21FEDFD35_D15E0120_01 +FFFBFFFFFFFFFFFF_D8800000_01 +FFFFFFF0000007FE_D1800000_01 +FFFFFFFFFFDE0839_CA07DF1C_00 +FFF7FFFFFFFFFFFF_D9000000_01 +0000007FFFE000FF_52FFFFC0_01 +FFFFFFFF79F30F48_CF060CF1_01 +FFEFFFFFFFFFFFFF_D9800000_01 +FFFFFC13FFFFFFFD_D47B0000_01 +0000000000001B85_45DC2800_00 +FFDFFFFFFFFFFFFF_DA000000_01 +000008000007FFFE_55000000_01 +12DB4409E5AE87E6_5D96DA20_01 +FFBFFFFFFFFFFFFF_DA800000_01 +FFFFFFFFFFF7BFEE_C9040120_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FF7FFFFFFFFFFFFF_DB000000_01 +000000001040FFFE_4D820800_01 +00000909A09C13D3_55109A0A_01 +FEFFFFFFFFFFFFFF_DB800000_01 +FFFFFF01FFFFFF7F_D37E0000_01 +FFFFFF72E7D2575D_D30D182E_01 +FDFFFFFFFFFFFFFF_DC000000_01 +FFFFFFFFFFFEFFDB_C7801280_00 +0000000000000017_41B80000_00 +FBFFFFFFFFFFFFFF_DC800000_01 +100000001FFFFFF6_5D800000_01 +000000114B12EF51_518A5897_01 +F7FFFFFFFFFFFFFF_DD000000_01 +0407FFFFFFFFFEFF_5C810000_01 +FFFFFF769F3A5C2C_D30960C6_01 +EFFFFFFFFFFFFFFF_DD800000_01 +FFFFFFFDF7FFFFFD_D0020000_01 +FFFFFFFFFFFFFFF2_C1600000_00 +DFFFFFFFFFFFFFFF_DE000000_01 +FFFFFFFFFE0007FF_CBFFFC00_01 +000000000000001E_41F00000_00 +BFFFFFFFFFFFFFFF_DE800000_01 +FFF800000009FFFF_D9000000_01 +0000000000007AA4_46F54800_00 +7FFFFFFFFFFFFFFF_5F000000_01 +4080000000FFFFFF_5E810000_01 +000000000DE7601D_4D5E7602_01 +3FFFFFFFFFFFFFFF_5E800000_01 +FFCFFFFFFFBFFFFE_DA400000_01 +FFFFFFFFFFFFFFCA_C2580000_00 +1FFFFFFFFFFFFFFF_5E000000_01 +000080400000003F_57004000_01 +00000000001F75A5_49FBAD28_00 +0FFFFFFFFFFFFFFF_5D800000_01 +FFFFFFEFFFFFCFFE_D1800002_01 +FFFFFEE775887420_D38C453C_01 +07FFFFFFFFFFFFFF_5D000000_01 +00000000000801FE_49001FE0_00 +0000000000213FF1_4A04FFC4_00 +03FFFFFFFFFFFFFF_5C800000_01 +07FEFFFFFFFFFFEE_5CFFE000_01 +0000000000000004_40800000_00 +01FFFFFFFFFFFFFF_5C000000_01 +0000000820000003_51020000_01 +FFFFFFF9AD105214_D0CA5DF6_01 +00FFFFFFFFFFFFFF_5B800000_01 +FFFFF00FFFFFFFBE_D57F0000_01 +FFFFFFFFFFCC48E7_CA4EDC64_00 +007FFFFFFFFFFFFF_5B000000_01 +00000FFFEF7FFFFF_557FFEF8_01 +FFFFFFFFFF0BA6CB_CB745935_00 +003FFFFFFFFFFFFF_5A800000_01 +FFFFFF7FBFFFFFBF_D3004000_01 +FFFFFFFFFFF24425_C95BBDB0_00 +001FFFFFFFFFFFFF_5A000000_01 +200000001FFBFFFF_5E000000_01 +FFFFFF4E7115EC53_D3318EEA_01 +000FFFFFFFFFFFFF_59800000_01 +FFFFF803FFFFFFBF_D4FF8000_01 +FFFFFC2E539ADCFE_D4746B19_01 +0007FFFFFFFFFFFF_59000000_01 +FFFFFFFFFBFFFFFF_CC800000_01 +00000055084732F3_52AA108E_01 +0003FFFFFFFFFFFF_58800000_01 +BFFF7FFFFFFFFE00_DE800100_01 +FFFFFFFFFFFF8543_C6F57A00_00 +0001FFFFFFFFFFFF_58000000_01 +0000001FFBFFE000_51FFDFFF_00 +FFFFFFFFFFFE491B_C7DB7280_00 +0000FFFFFFFFFFFF_57800000_01 +FC00200000001FFE_DC7FF800_01 +FFFFF16898822A24_D5697678_01 +00007FFFFFFFFFFF_57000000_01 +3FFF03FFFFFFFFFE_5E7FFC10_01 +FFFFFF8FFE18C7BF_D2E003CE_01 +00003FFFFFFFFFFF_56800000_01 +FFFFFEFFFEFFFFFD_D3800080_01 +00F03620C1266ED9_5B703621_01 +00001FFFFFFFFFFF_56000000_01 +BF7EFFFFFFFFFFFF_DE810200_01 +FFFFFFFFFFFFFFD5_C22C0000_00 +00000FFFFFFFFFFF_55800000_01 +FFFBFFFFF803FFFE_D8800001_01 +0000000000068684_48D0D080_00 +000007FFFFFFFFFF_55000000_01 +DFFFFFE00000001E_DE000000_01 +FFFFFFFFFFFFECF5_C5985800_00 +000003FFFFFFFFFF_54800000_01 +FFFF00400000FFFF_D77FC000_01 +0000000000000002_40000000_00 +000001FFFFFFFFFF_54000000_01 +FBFFFFFFFFFFBDFE_DC800000_01 +0000000000000BC9_453C9000_00 +000000FFFFFFFFFF_53800000_01 +807FFFFFFFFFDFFE_DEFF0000_01 +FFC274E35A70CD76_DA762C73_01 +0000007FFFFFFFFF_53000000_01 +0FFFFFFFFEFFFFFD_5D800000_01 +FFFFFFFF00E73AFC_CF7F18C5_01 +0000003FFFFFFFFF_52800000_01 +FFC000000001000E_DA800000_01 +FFFFFFFFFFFE15E9_C7F50B80_00 +0000001FFFFFFFFF_52000000_01 +0001FFFFFFFFF3FD_58000000_01 +0000000000000033_424C0000_00 +0000000FFFFFFFFF_51800000_01 +000000001FFFBFFF_4DFFFE00_01 +FFFFFFEE6B141E1B_D18CA75F_01 +00000007FFFFFFFF_51000000_01 +FFFFFFFFF60007FF_CD1FFF80_01 +00000001AB310BA6_4FD59886_01 +00000003FFFFFFFF_50800000_01 +0003FFFFB7FFFFFF_587FFFEE_01 +FFFFFFFFFFFFF195_C566B000_00 +00000001FFFFFFFF_50000000_01 +FFFFFFFF8000000B_CF000000_01 +00000019BA8D5559_51CDD46B_01 +00000000FFFFFFFF_4F800000_01 +FBFEFFFFFFFFFFF9_DC802000_01 +FFFFFFB6F062822D_D2921F3B_01 +000000007FFFFFFF_4F000000_01 +0001000000000082_57800000_01 +01CEAD9E2FB104A4_5BE756CF_01 +000000003FFFFFFF_4E800000_01 +000003FFFFFFFF7C_54800000_01 +FFFFFFFFFD681E78_CC25F862_00 +000000001FFFFFFF_4E000000_01 +00002000400001FF_56000100_01 +0000000000000018_41C00000_00 +000000000FFFFFFF_4D800000_01 +3FFF80000000003E_5E7FFE00_01 +FFFFFFFFFFFFFF95_C2D60000_00 +0000000007FFFFFF_4D000000_01 +010000BFFFFFFFFF_5B800060_01 +0000001697087B19_51B4B844_01 +0000000003FFFFFF_4C800000_01 +FBFFFFFFFFEEFFFD_DC800000_01 +0000000E64BDFC55_51664BE0_01 +0000000001FFFFFF_4C000000_01 +FC00000001FFFFFE_DC800000_01 +FFFED156A62AB849_D79754AD_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_D0F80200_01 +00015354EAE7C259_57A9AA75_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFF0F4DF3C75_D170B20C_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_D8C00000_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_CB0001C0_00 +FFFFFFDB5433CB9B_D212AF31_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_D4000801_01 +FFFFFFFFFFDEAE1F_CA054784_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_CD7F8000_01 +FFFFFFFE7735DEC7_CFC46511_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFE0000_01 +000003757D8B12ED_545D5F63_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_D3FC0400_01 +00000A654064E046_55265406_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000000_01 +FFFFFFFFFFFFFFE7_C1C80000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5D000000_01 +FFFFAD78B3D6C3B6_D6A50E98_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +FFFFFFF70B77F34F_D10F4881_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_D2FFFF20_01 +0000013EB4D67EC8_539F5A6B_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_DE800040_01 +0005CEAF34EA1DC7_58B9D5E7_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900001_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000360D0_48583400_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B802000_01 +00C000708FF1BA51_5B400071_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_DCFFC000_01 +0F9E07DCC0BDC061_5D79E07E_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC000_01 +FFFFFFE1B9B2A079_D1F2326B_01 +000000000000003F_427C0000_00 +FFF80000000080FF_D9000000_01 +00000000001EB5B4_49F5ADA0_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +00000000005AC607_4AB58C0E_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_CF840000_01 +000005C5B9D66984_54B8B73B_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_DE7FF800_01 +00001D06B372AA06_55E8359C_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_ru.tv b/wally-pipelined/testbench/fp/i64_f32_ru.tv index b8828358f..e5f4d5dc5 100644 --- a/wally-pipelined/testbench/fp/i64_f32_ru.tv +++ b/wally-pipelined/testbench/fp/i64_f32_ru.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 5CFFFFC0_01 -0000000032CC8B7A 4E4B322E_01 -0000000000000000 00000000_00 -FFFFFFFFC0003FFE CE7FFF00_01 -032C857F319EDE38 5C4B2160_01 -0000000000000001 3F800000_00 -FFFFFBFFFFF8003E D4800000_01 -00394C79B6D3007B 5A6531E7_01 -0000000000000002 40000000_00 -FBFFFFF0000001FF DC800001_01 -0000000001AE458D 4BD722C7_01 -0000000000000004 40800000_00 -00040008000007FE 58800101_01 -F9EB456140D88764 DCC29753_01 -0000000000000008 41000000_00 -FFFFE400FFFFFFFE D5DFF800_01 -07DE834A248EDF36 5CFBD06A_01 -0000000000000010 41800000_00 -00000003FF001FFF 507FC008_01 -FFFFFFFFFFE385E2 C9E3D0F0_00 -0000000000000020 42000000_00 -F0041FFFFFFFFFFF DD7FBE00_01 -000000059EB1FD45 50B3D640_01 -0000000000000040 42800000_00 -FFFFFFFFFFFCFFF9 C84001C0_00 -FFFFFFFFFFFEDDFE C7910100_00 -0000000000000080 43000000_00 -000000000003FF00 487FC000_00 -00000000C89FF56B 4F489FF6_01 -0000000000000100 43800000_00 -000FFFFF7FDFFFFF 597FFFF8_01 -1B5E4F0BE0DEBFF0 5DDAF279_01 -0000000000000200 44000000_00 -FFFDF803FFFFFFFF D801FF00_01 -FFFFFFFFFFF4766B C9389950_00 -0000000000000400 44800000_00 -0000080100000FFE 55001001_01 -000000000000000C 41400000_00 -0000000000000800 45000000_00 -0048000000100000 5A900001_01 -FFE662A109109D0A D9CCEAF7_01 -0000000000001000 45800000_00 -C000000037FFFFFE DE7FFFFF_01 -FFFFFFFFFFFFFFE4 C1E00000_00 -0000000000002000 46000000_00 -F801000000100000 DCFFDFFF_01 -FE114B79075F70EE DBF75A43_01 -0000000000004000 46800000_00 -100000000001003E 5D800001_01 -00000000000003AC 446B0000_00 -0000000000008000 47000000_00 -200000FFFFFFF800 5E000004_01 -00000044A3A3DBE5 52894748_01 -0000000000010000 47800000_00 -FFE0003EFFFFFFFF D9FFFE08_01 -FFFFFFFFFFFF1A91 C7656F00_00 -0000000000020000 48000000_00 -FFFFF7C3FFFFFFFD D503C000_01 -0000000000003309 464C2400_00 -0000000000040000 48800000_00 -000083FFF7FFFFFE 5703FFF8_01 -FFFFFFFFFFFFFF58 C3280000_00 -0000000000080000 49000000_00 -FFFFFFDE01FFFFFE D207F800_01 -0000000000002980 46260000_00 -0000000000100000 49800000_00 -00000000FFF07FFF 4F7FF080_01 -000000000000005D 42BA0000_00 -0000000000200000 4A000000_00 -000020FFDFFFFFFF 5603FF80_01 -FFFC8C23DA2CEAD8 D85CF709_01 -0000000000400000 4A800000_00 -E0000000003FFFDF DDFFFFFF_01 -FFFFFDE3C1DEC43C D4070F88_01 -0000000000800000 4B000000_00 -FFFF00000BFFFFFD D77FFFF4_01 -000000000030FFBE 4A43FEF8_00 -0000000001000000 4B800000_00 -FFFE000007FFEFFD D7FFFFFC_01 -FFFFFFFFEFDEED86 CD810893_01 -0000000002000000 4C000000_00 -F3FFFFFFFFBFFFFE DD400000_01 -000000001DA3FF45 4DED1FFB_01 -0000000004000000 4C800000_00 -FFFFFFFF00010007 CF7FFEFF_01 -FFFFFFFE9B1BCB54 CFB2721A_01 -0000000008000000 4D000000_00 -00004000004001FE 56800001_01 -F27DD19DE6563714 DD5822E6_01 -0000000010000000 4D800000_00 -FFC00000004007FE DA7FFFFF_01 -000000000001A359 47D1AC80_00 -0000000020000000 4E000000_00 -0000000003C000FE 4C700040_01 -FFFFFFFFFE62EC20 CBCE89F0_00 -0000000040000000 4E800000_00 -000000003FFFFFFD 4E800000_01 -000000000000285F 46217C00_00 -0000000080000000 4F000000_00 -FFFFFFFFBFFFF00F CE80001F_01 -FFFFF836F99DBAA8 D4F920CC_01 -0000000100000000 4F800000_00 -00000020003FFEFE 52000100_01 -0033466832042D47 5A4D19A1_01 -0000000200000000 50000000_00 -FFFFFFFFFFFFF887 C4EF2000_00 -00000000003829C8 4A60A720_00 -0000000400000000 50800000_00 -00000FFFFFFF7DFD 55800000_01 -0000000FB77C672B 517B77C7_01 -0000000800000000 51000000_00 -08003FFDFFFFFFFE 5D000400_01 -0000000000001B78 45DBC000_00 -0000001000000000 51800000_00 -FF7FFFFFFFEFDFFF DB000000_01 -0000000000000071 42E20000_00 -0000002000000000 52000000_00 -000013FFFFFFFDFF 55A00000_01 -FFFFFFFFFFFFFF86 C2F40000_00 -0000004000000000 52800000_00 -0800000000040800 5D000001_01 -FFF8A60D9E19F17E D8EB3E4C_01 -0000008000000000 53000000_00 -000077FFF0000000 56EFFFE0_00 -FFFFFFFFF7506DBA CD0AF924_01 -0000010000000000 53800000_00 -FFFFFFFFFFFEFBF7 C7820480_00 -FFFFFFFFFEA42AC9 CBADEA9B_01 -0000020000000000 54000000_00 -0000107FFFFFDFFD 55840000_01 -FFE7AA3F2BDACC89 D9C2AE06_01 -0000040000000000 54800000_00 -FFF8040000040000 D8FF7FFF_01 -FFFFFFFFFFFFFFFD C0400000_00 -0000080000000000 55000000_00 -FFFF80000800001F D6FFFFEF_01 -FFFDF681DECDADC9 D8025F88_01 -0000100000000000 55800000_00 -FFFFFEFFFFE0007F D380000F_01 -FFFFFFFFFFFFCFBE C6410800_00 -0000200000000000 56000000_00 -0000000901FFFFFD 51102000_01 -FEC01FECA24DE1B0 DB9FF009_01 -0000400000000000 56800000_00 -F7FFFFFFDFFF7FFF DD000000_01 -F858A66761669936 DCF4EB33_01 -0000800000000000 57000000_00 -FFFEFF800000003E D7803FFF_01 -F716EA43FAC45C97 DD0E915B_01 -0001000000000000 57800000_00 -FFFFFFFFFFFFFFC6 C2680000_00 -0024D70EC7661FD8 5A135C3C_01 -0002000000000000 58000000_00 -C07FFFFFFFFFFFFE DE7E0000_01 -FFD956DBD0AEE817 DA1AA490_01 -0004000000000000 58800000_00 -020003EFFFFFFFFE 5C0000FC_01 -FFFFFFFFFFFF4300 C73D0000_00 -0008000000000000 59000000_00 -4000000004002000 5E800001_01 -C12EDF40F41F6021 DE7B4482_01 -0010000000000000 59800000_00 -FF9000000000001D DADFFFFF_01 -FFFFFFF83DE950F6 D0F842D5_01 -0020000000000000 5A000000_00 -800003FFFFFC0000 DEFFFFF8_01 -FE2B59CB3A604D69 DBEA531A_01 -0040000000000000 5A800000_00 -7FFFFFFDFFFFBFFF 5F000000_01 -000000A37C210862 53237C22_01 -0080000000000000 5B000000_00 -0002000002000002 58000001_01 -FFFFB65CD8617789 D693464F_01 -0100000000000000 5B800000_00 -00001BFFFFFFBFFE 55E00000_01 -FFFFFFFFFFFFF01D C57E3000_00 -0200000000000000 5C000000_00 -1000008000003FFF 5D800005_01 -000000000D098D19 4D5098D2_01 -0400000000000000 5C800000_00 -03FFFFFFFFFFF5FF 5C800000_01 -000006B3BD2C7BEF 54D677A6_01 -0800000000000000 5D000000_00 -00003FFFBFFFFFFE 567FFF00_01 -FFFF4E5ADDDAA4A8 D731A522_01 -1000000000000000 5D800000_00 -001FFFC000000FFD 59FFFE01_01 -FFFFFFFFFFFFFF21 C35F0000_00 -2000000000000000 5E000000_00 -0000000041DFFFFF 4E83C000_01 -FFFFFFFFFC648262 CC66DF67_01 -4000000000000000 5E800000_00 -C0001FFFFFFFFFFB DE7FFF80_01 -FFFFFF7353AC45D2 D30CAC53_01 -8000000000000000 DF000000_00 -FFFFFFFFFFE7EFFF C9C08008_00 -0000000000A1202D 4B21202D_00 -C000000000000000 DE800000_00 -FFFFFFFFFFFF5F7F C7208100_00 -000000000040CA70 4A8194E0_00 -E000000000000000 DE000000_00 -0000200201FFFFFE 56000808_01 -00000003B55D87D4 506D5762_01 -F000000000000000 DD800000_00 -FF80000DFFFFFFFF DAFFFFE4_01 -000000010510FAEF 4F82887E_01 -F800000000000000 DD000000_00 -0003FFF00000000F 587FFC01_01 -000000000000724A 46E49400_00 -FC00000000000000 DC800000_00 -FFFFFFDF80000002 D201FFFF_01 -0000000000000064 42C80000_00 -FE00000000000000 DC000000_00 -FEFFFFFFFFF800FE DB800000_01 -FFFFFFC2C6222702 D274E777_01 -FF00000000000000 DB800000_00 -0000000408000002 50810001_01 -000000E96DF1CB41 53696DF2_01 -FF80000000000000 DB000000_00 -007FFFFFFFFFF9FE 5B000000_01 -F727F174DEE7DC85 DD0D80E8_01 -FFC0000000000000 DA800000_00 -8000000003FFFEFE DEFFFFFF_01 -FFFFFFFFFFF0BD5B C9742A50_00 -FFE0000000000000 DA000000_00 -0BEFFFFFFFFFFFFF 5D3F0000_01 -000000000002790C 481E4300_00 -FFF0000000000000 D9800000_00 -FFFFFFFFFFEFFBFA C9802030_00 -000000169E75DF01 51B4F3AF_01 -FFF8000000000000 D9000000_00 -00000007FEFFDFFF 50FFDFFC_01 -000000000000000E 41600000_00 -FFFC000000000000 D8800000_00 -0003FFFE0007FFFE 587FFF81_01 -FFFFFFFFFFF28622 C9579DE0_00 -FFFE000000000000 D8000000_00 -FFFFFF7FFFFDF7FF D3000002_01 -00072F0EC496FE21 58E5E1D9_01 -FFFF000000000000 D7800000_00 -DFBFFFFFFFFFFFFE DE010000_01 -0000000000FC1FCA 4B7C1FCA_00 -FFFF800000000000 D7000000_00 -00000FFF800FFFFE 557FF801_01 -FFFF5194E4A9C2CE D72E6B1B_01 -FFFFC00000000000 D6800000_00 -00000002100007FD 50040002_01 -FFFFFFFFFFC2D8FE CA749C08_00 -FFFFE00000000000 D6000000_00 -000000000007FF6E 48FFEDC0_00 -000000000001766E 47BB3700_00 -FFFFF00000000000 D5800000_00 -0040000400000002 5A800009_01 -0000000000007841 46F08200_00 -FFFFF80000000000 D5000000_00 -3DFFFFFFFFFFFF7E 5E780000_01 -FFFFFFE549E17E30 D1D5B0F4_01 -FFFFFC0000000000 D4800000_00 -FFFFFFFFFFFFFEE1 C38F8000_00 -FFFFFFFFFFFFFFE7 C1C80000_00 -FFFFFE0000000000 D4000000_00 -000000000EFFFFDF 4D6FFFFE_01 -FFFFFFFFFFFFFF73 C30D0000_00 -FFFFFF0000000000 D3800000_00 -FD00000008000000 DC3FFFFF_01 -000000000001DBB1 47EDD880_00 -FFFFFF8000000000 D3000000_00 -FFFFFFFFFFF8007F C8FFF020_00 -FFFFFFFEFD10A515 CF8177AD_01 -FFFFFFC000000000 D2800000_00 -FFEFFFFFFFFFFFFE D9800000_01 -FAB02984F6283B6C DCA9FACF_01 -FFFFFFE000000000 D2000000_00 -FFFFFFBC000001FE D287FFFF_01 -FEB087C6B9FE7FE0 DBA7BC1C_01 -FFFFFFF000000000 D1800000_00 -FFF80001000007FE D8FFFFDF_01 -00F2762EA6837956 5B72762F_01 -FFFFFFF800000000 D1000000_00 -FFF7E0FFFFFFFFFE D901F000_01 -00002E1175484626 563845D6_01 -FFFFFFFC00000000 D0800000_00 -0000200020000FFE 56000081_01 -000000000000068F 44D1E000_00 -FFFFFFFE00000000 D0000000_00 -021FFFFFFFFBFFFF 5C080000_01 -FFFFFFFFFFFFFFF9 C0E00000_00 -FFFFFFFF00000000 CF800000_00 -FFFFFFD0000FFFFD D23FFFC0_01 -000000BDF6658B83 533DF666_01 -FFFFFFFF80000000 CF000000_00 -1000001FFDFFFFFF 5D800001_01 -0000000000003B5B 466D6C00_00 -FFFFFFFFC0000000 CE800000_00 -FFFFFFBFFE0FFFFF D28003E0_01 -FFFFFFFFFFFFFFF0 C1800000_00 -FFFFFFFFE0000000 CE000000_00 -FFFFFFFBF00007FF D081FFFF_01 -01E986274F48EAAD 5BF4C314_01 -FFFFFFFFF0000000 CD800000_00 -1FFFFFFDFFFFFF7F 5E000000_01 -FFFFFFFFFFFFCB5A C6529800_00 -FFFFFFFFF8000000 CD000000_00 -7FF000000000FFFF 5EFFE001_01 -00000003C2717FC3 50709C60_01 -FFFFFFFFFC000000 CC800000_00 -FFFFFFE00008001F D1FFFFBF_01 -FFFFFFFFFFEFABDA C982A130_00 -FFFFFFFFFE000000 CC000000_00 -0200000000000002 5C000001_01 -FFFFFFFFF8FDA53F CCE04B58_01 -FFFFFFFFFF000000 CB800000_00 -F6000003FFFFFFFE DD1FFFFF_01 -FFFFFFFFFFFFFFD0 C2400000_00 -FFFFFFFFFF800000 CB000000_00 -FFFFFFFFFFBFFF7E CA800104_00 -00000000EE0FEA62 4F6E0FEB_01 -FFFFFFFFFFC00000 CA800000_00 -0000007FFF9FFFFD 52FFFF40_01 -00000037F35EDC1D 525FCD7C_01 -FFFFFFFFFFE00000 CA000000_00 -FFFFFFF7FDFFFF7D D1002000_01 -00000000000001AD 43D68000_00 -FFFFFFFFFFF00000 C9800000_00 -FFFFFF0000100020 D37FFFEF_01 -27F167FBC7FC5F9A 5E1FC5A0_01 -FFFFFFFFFFF80000 C9000000_00 -003FFFFFFFFC0001 5A800000_01 -000E48F9F4EBD30E 59648FA0_01 -FFFFFFFFFFFC0000 C8800000_00 -DFFFFFFFFFFBFFFE DE000000_01 -FC91C23EE8C9424F DC5B8F70_01 -FFFFFFFFFFFE0000 C8000000_00 -F7DFFBFFFFFFFFFE DD020040_01 -000000002CAE080C 4E32B821_01 -FFFFFFFFFFFF0000 C7800000_00 -FFFFC00010000020 D67FFFBF_01 -04D921F917B20E40 5C9B2440_01 -FFFFFFFFFFFF8000 C7000000_00 -F8000FFFFFFFFFFD DCFFFE00_01 -FFF17C566BC7D811 D9683A99_01 -FFFFFFFFFFFFC000 C6800000_00 -00000000000000FE 437E0000_00 -FFF82AC14930D386 D8FAA7D6_01 -FFFFFFFFFFFFE000 C6000000_00 -00000000000003FC 447F0000_00 -000E62EC60E119FC 59662EC7_01 -FFFFFFFFFFFFF000 C5800000_00 -FFFFEFF7FF7FFFFE D5804004_01 -0E2B1ECF210EEDC5 5D62B1ED_01 -FFFFFFFFFFFFF800 C5000000_00 -00000000007FFF1F 4AFFFE3E_00 -FFFFFE534F5676F7 D3D65854_01 -FFFFFFFFFFFFFC00 C4800000_00 -0000001004FFFFFD 51802800_01 -0000035C939669F1 545724E6_01 -FFFFFFFFFFFFFE00 C4000000_00 -1FFFFFFFFFFFFDFD 5E000000_01 -FFFFFFFFFFFFFF91 C2DE0000_00 -FFFFFFFFFFFFFF00 C3800000_00 -01FFFFFFFBFFEFFE 5C000000_01 -000000000000016E 43B70000_00 -FFFFFFFFFFFFFF80 C3000000_00 -FFF7FFFFFFFFF7FD D9000000_01 -FFFFF8E2BCFAC553 D4E3A860_01 -FFFFFFFFFFFFFFC0 C2800000_00 -FFFFFBFFFFFE0FFE D4800000_01 -00000001A4E704BF 4FD27383_01 -FFFFFFFFFFFFFFE0 C2000000_00 -1400007FFFFFFFFD 5DA00004_01 -FFFFFFFC93B187B4 D05B139E_01 -FFFFFFFFFFFFFFF0 C1800000_00 -40000000007FFFFD 5E800001_01 -000000000067D468 4ACFA8D0_00 -FFFFFFFFFFFFFFF8 C1000000_00 -007FFEFFFFFBFFFE 5AFFFE00_01 -FFFFFFE26CEC79F8 D1EC989C_01 -FFFFFFFFFFFFFFFC C0800000_00 -00FFFFFF000000FF 5B800000_01 -FFFFFFFFE0D3983A CDF9633E_01 -FFFFFFFFFFFFFFFE C0000000_00 -00007FFFBFFF7FFE 56FFFF80_01 -FFFFFFFDF4A7088A D002D63D_01 -FFFFFFFFFFFFFFFF BF800000_00 -000008000000027E 55000001_01 -000000000000F4E8 4774E800_00 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFF83FFDF CAF80042_00 -00000E11407887B2 55611408_01 -FFFFFFFFFFFFFFFB C0A00000_00 -04000003FFFFFFF6 5C800001_01 -0000000000000513 44A26000_00 -FFFFFFFFFFFFFFF7 C1100000_00 -BFFC00000000003E DE8007FF_01 -00000008D7BBB75B 510D7BBC_01 -FFFFFFFFFFFFFFEF C1880000_00 -000FFFFBFFFC0000 597FFFC0_01 -FFFFFFFFFFCD5A23 CA4A9774_00 -FFFFFFFFFFFFFFDF C2040000_00 -FFBFDFFFBFFFFFFF DA804000_01 -000000000000007F 42FE0000_00 -FFFFFFFFFFFFFFBF C2820000_00 -00000007FF800003 50FFF001_01 -000000000002BB02 482EC080_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEE7FF C78C0080_00 -00264B2B9BAD0DA2 5A192CAF_01 -FFFFFFFFFFFFFEFF C3808000_00 -0000000000100803 49804018_00 -FF9B1DCB9F857D5E DAC9C468_01 -FFFFFFFFFFFFFDFF C4004000_00 -FFFFFFBFFFFFEFEE D2800000_01 -F6FD7542899C1C6F DD1028AB_01 -FFFFFFFFFFFFFBFF C4802000_00 -FF800000004001FF DAFFFFFF_01 -0000000002BE4932 4C2F924D_01 -FFFFFFFFFFFFF7FF C5001000_00 -00001004000FFFFE 55802001_01 -FFFFFF9DAA0123E0 D2C4ABFD_01 -FFFFFFFFFFFFEFFF C5800800_00 -00000001FDFFFDFE 4FFEFFFF_01 -FFFC1C8703B1DCB0 D878DE3F_01 -FFFFFFFFFFFFDFFF C6000400_00 -FE0FE00000000000 DBF81000_00 -0779ED944A4E2779 5CEF3DB3_01 -FFFFFFFFFFFFBFFF C6800200_00 -FBFFFE0400000000 DC80003F_01 -0000010127E03666 538093F1_01 -FFFFFFFFFFFF7FFF C7000100_00 -FFFFF0200000FFFE D57DFFFF_01 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEFFFF C7800080_00 -FFEFFE0000080000 D9800FFF_01 -FFFFFFFFFD3354EA CC332AC5_01 -FFFFFFFFFFFDFFFF C8000040_00 -003FF0000003FFFE 5A7FC001_01 -0000006375B23F7B 52C6EB65_01 -FFFFFFFFFFFBFFFF C8800020_00 -000407FFFFFFFFF6 58810000_01 -0000000092117F38 4F121180_01 -FFFFFFFFFFF7FFFF C9000010_00 -FFFFFFFFFFFF7FFF C7000100_00 -00000000000008BE 450BE000_00 -FFFFFFFFFFEFFFFF C9800008_00 -004000020FFFFFFF 5A800005_01 -FFFFB84C2D8BC9CB D68F67A4_01 -FFFFFFFFFFDFFFFF CA000004_00 -00FFFFFFFFFFFFFD 5B800000_01 -00000023C2C6F284 520F0B1C_01 -FFFFFFFFFFBFFFFF CA800002_00 -FFFDDFFFFFFFFFFD D8080000_01 -00000000746356C4 4EE8C6AE_01 -FFFFFFFFFF7FFFFF CB000001_00 -010000000000BFFF 5B800001_01 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFEFFFFFF CB800000_01 -FFFFBF7FFBFFFFFE D6810008_01 -00000006386CE889 50C70D9E_01 -FFFFFFFFFDFFFFFF CC000000_01 -F00000F7FFFFFFFF DD7FFFF0_01 -FFFDFC53090C46A4 D800EB3D_01 -FFFFFFFFFBFFFFFF CC800000_01 -0000000000800047 4B000047_00 -FFFFFFFFD693872E CE25B1E3_01 -FFFFFFFFF7FFFFFF CD000000_01 -000000007FBFFBFF 4EFF7FF8_01 -00000026A7845E35 521A9E12_01 -FFFFFFFFEFFFFFFF CD800000_01 -FFFFFFDFFFFFFBFD D2000000_01 -000000001433D14C 4DA19E8B_01 -FFFFFFFFDFFFFFFF CE000000_01 -0001FFFFFFE0000E 58000000_01 -F0F23E8068D3D84A DD70DC17_01 -FFFFFFFFBFFFFFFF CE800000_01 -F7FFBFFFFFFFBFFF DD000400_01 -FFFFBD29B7459087 D685AC91_01 -FFFFFFFF7FFFFFFF CF000000_01 -FFFFFFF8FFFFBFFF D0E00008_01 -FFFFFFFFFFEDDC06 C9911FD0_00 -FFFFFFFEFFFFFFFF CF800000_01 -FFFFFFF80001FFFF D0FFFFC0_01 -0000000000002FF9 463FE400_00 -FFFFFFFDFFFFFFFF D0000000_01 -004000040000FFFF 5A800009_01 -FFFFFFFFFFFFFFF1 C1700000_00 -FFFFFFFBFFFFFFFF D0800000_01 -C0000000007FFFFA DE7FFFFF_01 -FFFFFFFFFE053E2B CBFD60EA_01 -FFFFFFF7FFFFFFFF D1000000_01 -7FFE000007FFFFFF 5EFFFC01_01 -000000000000000D 41500000_00 -FFFFFFEFFFFFFFFF D1800000_01 -F80000000001007E DCFFFFFF_01 -FFFFED48424AD9D6 D595BDED_01 -FFFFFFDFFFFFFFFF D2000000_01 -FFFFFE0001FEFFFF D3FFFF00_01 -000000000000013B 439D8000_00 -FFFFFFBFFFFFFFFF D2800000_01 -0007FBFFFFFDFFFE 58FF8000_01 -4A16BD4128090C83 5E942D7B_01 -FFFFFF7FFFFFFFFF D3000000_01 -00FFF7FFFF7FFFFE 5B7FF800_01 -0000000000000006 40C00000_00 -FFFFFEFFFFFFFFFF D3800000_01 -FBFFFFBFFFBFFFFF DC800008_01 -00000000000001BA 43DD0000_00 -FFFFFDFFFFFFFFFF D4000000_01 -0000000040000082 4E800002_01 -FF07A2BF5B689F89 DB785D40_01 -FFFFFBFFFFFFFFFF D4800000_01 -0000001FF8000008 51FFC001_01 -F87CAA7DE672DE8B DCF06AB0_01 -FFFFF7FFFFFFFFFF D5000000_01 -07FFF80000000002 5CFFFF01_01 -0000000010A1E5B8 4D850F2E_01 -FFFFEFFFFFFFFFFF D5800000_01 -F7FFFFE00007FFFF DD000001_01 -FFFFFFFFFFF6ADFC C9152040_00 -FFFFDFFFFFFFFFFF D6000000_01 -FFFFFF03FFFFFFC0 D37C0000_01 -EA579475948F0032 DDAD435C_01 -FFFFBFFFFFFFFFFF D6800000_01 -FC00000000003FF6 DC7FFFFF_01 -002E677AC313BF60 5A399DEC_01 -FFFF7FFFFFFFFFFF D7000000_01 -02000007FF7FFFFF 5C000002_01 -0000000E999639F1 51699964_01 -FFFEFFFFFFFFFFFF D7800000_01 -FFFF83FFFFFFFFBE D6F80000_01 -000000000001537D 47A9BE80_00 -FFFDFFFFFFFFFFFF D8000000_01 -EFFFFFC00000003D DD800001_01 -FFFFFFF21FEDFD35 D15E0120_01 -FFFBFFFFFFFFFFFF D8800000_01 -FFFFFFF0000007FE D17FFFFF_01 -FFFFFFFFFFDE0839 CA07DF1C_00 -FFF7FFFFFFFFFFFF D9000000_01 -0000007FFFE000FF 52FFFFC1_01 -FFFFFFFF79F30F48 CF060CF0_01 -FFEFFFFFFFFFFFFF D9800000_01 -FFFFFC13FFFFFFFD D47B0000_01 -0000000000001B85 45DC2800_00 -FFDFFFFFFFFFFFFF DA000000_01 -000008000007FFFE 55000001_01 -12DB4409E5AE87E6 5D96DA21_01 -FFBFFFFFFFFFFFFF DA800000_01 -FFFFFFFFFFF7BFEE C9040120_00 -FFFFFFFFFFFFFFFD C0400000_00 -FF7FFFFFFFFFFFFF DB000000_01 -000000001040FFFE 4D820800_01 -00000909A09C13D3 55109A0A_01 -FEFFFFFFFFFFFFFF DB800000_01 -FFFFFF01FFFFFF7F D37E0000_01 -FFFFFF72E7D2575D D30D182D_01 -FDFFFFFFFFFFFFFF DC000000_01 -FFFFFFFFFFFEFFDB C7801280_00 -0000000000000017 41B80000_00 -FBFFFFFFFFFFFFFF DC800000_01 -100000001FFFFFF6 5D800001_01 -000000114B12EF51 518A5898_01 -F7FFFFFFFFFFFFFF DD000000_01 -0407FFFFFFFFFEFF 5C810000_01 -FFFFFF769F3A5C2C D30960C5_01 -EFFFFFFFFFFFFFFF DD800000_01 -FFFFFFFDF7FFFFFD D0020000_01 -FFFFFFFFFFFFFFF2 C1600000_00 -DFFFFFFFFFFFFFFF DE000000_01 -FFFFFFFFFE0007FF CBFFFC00_01 -000000000000001E 41F00000_00 -BFFFFFFFFFFFFFFF DE800000_01 -FFF800000009FFFF D8FFFFFF_01 -0000000000007AA4 46F54800_00 -7FFFFFFFFFFFFFFF 5F000000_01 -4080000000FFFFFF 5E810001_01 -000000000DE7601D 4D5E7602_01 -3FFFFFFFFFFFFFFF 5E800000_01 -FFCFFFFFFFBFFFFE DA400000_01 -FFFFFFFFFFFFFFCA C2580000_00 -1FFFFFFFFFFFFFFF 5E000000_01 -000080400000003F 57004001_01 -00000000001F75A5 49FBAD28_00 -0FFFFFFFFFFFFFFF 5D800000_01 -FFFFFFEFFFFFCFFE D1800001_01 -FFFFFEE775887420 D38C453B_01 -07FFFFFFFFFFFFFF 5D000000_01 -00000000000801FE 49001FE0_00 -0000000000213FF1 4A04FFC4_00 -03FFFFFFFFFFFFFF 5C800000_01 -07FEFFFFFFFFFFEE 5CFFE000_01 -0000000000000004 40800000_00 -01FFFFFFFFFFFFFF 5C000000_01 -0000000820000003 51020001_01 -FFFFFFF9AD105214 D0CA5DF5_01 -00FFFFFFFFFFFFFF 5B800000_01 -FFFFF00FFFFFFFBE D57F0000_01 -FFFFFFFFFFCC48E7 CA4EDC64_00 -007FFFFFFFFFFFFF 5B000000_01 -00000FFFEF7FFFFF 557FFEF8_01 -FFFFFFFFFF0BA6CB CB745935_00 -003FFFFFFFFFFFFF 5A800000_01 -FFFFFF7FBFFFFFBF D3004000_01 -FFFFFFFFFFF24425 C95BBDB0_00 -001FFFFFFFFFFFFF 5A000000_01 -200000001FFBFFFF 5E000001_01 -FFFFFF4E7115EC53 D3318EEA_01 -000FFFFFFFFFFFFF 59800000_01 -FFFFF803FFFFFFBF D4FF8000_01 -FFFFFC2E539ADCFE D4746B19_01 -0007FFFFFFFFFFFF 59000000_01 -FFFFFFFFFBFFFFFF CC800000_01 -00000055084732F3 52AA108F_01 -0003FFFFFFFFFFFF 58800000_01 -BFFF7FFFFFFFFE00 DE800100_01 -FFFFFFFFFFFF8543 C6F57A00_00 -0001FFFFFFFFFFFF 58000000_01 -0000001FFBFFE000 51FFDFFF_00 -FFFFFFFFFFFE491B C7DB7280_00 -0000FFFFFFFFFFFF 57800000_01 -FC00200000001FFE DC7FF7FF_01 -FFFFF16898822A24 D5697677_01 -00007FFFFFFFFFFF 57000000_01 -3FFF03FFFFFFFFFE 5E7FFC10_01 -FFFFFF8FFE18C7BF D2E003CE_01 -00003FFFFFFFFFFF 56800000_01 -FFFFFEFFFEFFFFFD D3800080_01 -00F03620C1266ED9 5B703621_01 -00001FFFFFFFFFFF 56000000_01 -BF7EFFFFFFFFFFFF DE810200_01 -FFFFFFFFFFFFFFD5 C22C0000_00 -00000FFFFFFFFFFF 55800000_01 -FFFBFFFFF803FFFE D8800000_01 -0000000000068684 48D0D080_00 -000007FFFFFFFFFF 55000000_01 -DFFFFFE00000001E DE000000_01 -FFFFFFFFFFFFECF5 C5985800_00 -000003FFFFFFFFFF 54800000_01 -FFFF00400000FFFF D77FBFFF_01 -0000000000000002 40000000_00 -000001FFFFFFFFFF 54000000_01 -FBFFFFFFFFFFBDFE DC800000_01 -0000000000000BC9 453C9000_00 -000000FFFFFFFFFF 53800000_01 -807FFFFFFFFFDFFE DEFF0000_01 -FFC274E35A70CD76 DA762C72_01 -0000007FFFFFFFFF 53000000_01 -0FFFFFFFFEFFFFFD 5D800000_01 -FFFFFFFF00E73AFC CF7F18C5_01 -0000003FFFFFFFFF 52800000_01 -FFC000000001000E DA7FFFFF_01 -FFFFFFFFFFFE15E9 C7F50B80_00 -0000001FFFFFFFFF 52000000_01 -0001FFFFFFFFF3FD 58000000_01 -0000000000000033 424C0000_00 -0000000FFFFFFFFF 51800000_01 -000000001FFFBFFF 4DFFFE00_01 -FFFFFFEE6B141E1B D18CA75F_01 -00000007FFFFFFFF 51000000_01 -FFFFFFFFF60007FF CD1FFF80_01 -00000001AB310BA6 4FD59886_01 -00000003FFFFFFFF 50800000_01 -0003FFFFB7FFFFFF 587FFFEE_01 -FFFFFFFFFFFFF195 C566B000_00 -00000001FFFFFFFF 50000000_01 -FFFFFFFF8000000B CEFFFFFF_01 -00000019BA8D5559 51CDD46B_01 -00000000FFFFFFFF 4F800000_01 -FBFEFFFFFFFFFFF9 DC802000_01 -FFFFFFB6F062822D D2921F3A_01 -000000007FFFFFFF 4F000000_01 -0001000000000082 57800001_01 -01CEAD9E2FB104A4 5BE756D0_01 -000000003FFFFFFF 4E800000_01 -000003FFFFFFFF7C 54800000_01 -FFFFFFFFFD681E78 CC25F862_00 -000000001FFFFFFF 4E000000_01 -00002000400001FF 56000101_01 -0000000000000018 41C00000_00 -000000000FFFFFFF 4D800000_01 -3FFF80000000003E 5E7FFE01_01 -FFFFFFFFFFFFFF95 C2D60000_00 -0000000007FFFFFF 4D000000_01 -010000BFFFFFFFFF 5B800060_01 -0000001697087B19 51B4B844_01 -0000000003FFFFFF 4C800000_01 -FBFFFFFFFFEEFFFD DC800000_01 -0000000E64BDFC55 51664BE0_01 -0000000001FFFFFF 4C000000_01 -FC00000001FFFFFE DC7FFFFF_01 -FFFED156A62AB849 D79754AC_01 -0000000000FFFFFF 4B7FFFFF_00 -FFFFFFF83FEFFFFD D0F80200_01 -00015354EAE7C259 57A9AA76_01 -00000000007FFFFF 4AFFFFFE_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFF0F4DF3C75 D170B20C_01 -00000000003FFFFF 4A7FFFFC_00 -FFFA000000001FFF D8BFFFFF_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000001FFFFF 49FFFFF8_00 -FFFFFFFFFF7FFE40 CB0001C0_00 -FFFFFFDB5433CB9B D212AF30_01 -00000000000FFFFF 497FFFF0_00 -FFFFFDFFDFFDFFFD D4000800_01 -FFFFFFFFFFDEAE1F CA054784_00 -000000000007FFFF 48FFFFE0_00 -FFFFFFFFF0080006 CD7F7FFF_01 -FFFFFFFE7735DEC7 CFC46510_01 -000000000003FFFF 487FFFC0_00 -00000001FBFFFFFF 4FFE0000_01 -000003757D8B12ED 545D5F63_01 -000000000001FFFF 47FFFF80_00 -FFFFFE07F7FFFFFF D3FC0400_01 -00000A654064E046 55265407_01 -000000000000FFFF 477FFF00_00 -08000000000017FF 5D000001_01 -FFFFFFFFFFFFFFE7 C1C80000_00 -0000000000007FFF 46FFFE00_00 -07FFFFFFFFFFFDF6 5D000000_01 -FFFFAD78B3D6C3B6 D6A50E98_01 -0000000000003FFF 467FFC00_00 -0000300004000000 56400010_00 -FFFFFFF70B77F34F D10F4880_01 -0000000000001FFF 45FFF800_00 -FFFFFF80006FFFFE D2FFFF20_01 -0000013EB4D67EC8 539F5A6C_01 -0000000000000FFF 457FF000_00 -BFFFDFFFFBFFFFFF DE800040_01 -0005CEAF34EA1DC7 58B9D5E7_01 -00000000000007FF 44FFE000_00 -00004800007FFFFD 56900001_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000000003FF 447FC000_00 -0000000200001000 50000004_00 -00000000000360D0 48583400_00 -00000000000001FF 43FF8000_00 -01003FFFFFFFFFFC 5B802000_01 -00C000708FF1BA51 5B400071_01 -00000000000000FF 437F0000_00 -F802000003FFFFFF DCFFBFFF_01 -0F9E07DCC0BDC061 5D79E07E_01 -000000000000007F 42FE0000_00 -03FF0000000000FF 5C7FC001_01 -FFFFFFE1B9B2A079 D1F2326A_01 -000000000000003F 427C0000_00 -FFF80000000080FF D8FFFFFF_01 -00000000001EB5B4 49F5ADA0_00 -000000000000001F 41F80000_00 -000000000077FBFE 4AEFF7FC_00 -00000000005AC607 4AB58C0E_00 -000000000000000F 41700000_00 -FFFFFFFEF80000FF CF83FFFF_01 -000005C5B9D66984 54B8B73B_01 -0000000000000007 40E00000_00 -C001FFFFFFF00000 DE7FF800_01 -00001D06B372AA06 55E8359C_01 -0000000000000003 40400000_00 +07FFFDFFFFFFFF7F_5CFFFFC0_01 +0000000032CC8B7A_4E4B322E_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_CE7FFF00_01 +032C857F319EDE38_5C4B2160_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_D4800000_01 +00394C79B6D3007B_5A6531E7_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_DC800001_01 +0000000001AE458D_4BD722C7_01 +0000000000000004_40800000_00 +00040008000007FE_58800101_01 +F9EB456140D88764_DCC29753_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_D5DFF800_01 +07DE834A248EDF36_5CFBD06A_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC008_01 +FFFFFFFFFFE385E2_C9E3D0F0_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_DD7FBE00_01 +000000059EB1FD45_50B3D640_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_C84001C0_00 +FFFFFFFFFFFEDDFE_C7910100_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000000C89FF56B_4F489FF6_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF8_01 +1B5E4F0BE0DEBFF0_5DDAF279_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_D801FF00_01 +FFFFFFFFFFF4766B_C9389950_00 +0000000000000400_44800000_00 +0000080100000FFE_55001001_01 +000000000000000C_41400000_00 +0000000000000800_45000000_00 +0048000000100000_5A900001_01 +FFE662A109109D0A_D9CCEAF7_01 +0000000000001000_45800000_00 +C000000037FFFFFE_DE7FFFFF_01 +FFFFFFFFFFFFFFE4_C1E00000_00 +0000000000002000_46000000_00 +F801000000100000_DCFFDFFF_01 +FE114B79075F70EE_DBF75A43_01 +0000000000004000_46800000_00 +100000000001003E_5D800001_01 +00000000000003AC_446B0000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000004_01 +00000044A3A3DBE5_52894748_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_D9FFFE08_01 +FFFFFFFFFFFF1A91_C7656F00_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_D503C000_01 +0000000000003309_464C2400_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF8_01 +FFFFFFFFFFFFFF58_C3280000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_D207F800_01 +0000000000002980_46260000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF080_01 +000000000000005D_42BA0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF80_01 +FFFC8C23DA2CEAD8_D85CF709_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_DDFFFFFF_01 +FFFFFDE3C1DEC43C_D4070F88_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_D77FFFF4_01 +000000000030FFBE_4A43FEF8_00 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_D7FFFFFC_01 +FFFFFFFFEFDEED86_CD810893_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_DD400000_01 +000000001DA3FF45_4DED1FFB_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_CF7FFEFF_01 +FFFFFFFE9B1BCB54_CFB2721A_01 +0000000008000000_4D000000_00 +00004000004001FE_56800001_01 +F27DD19DE6563714_DD5822E6_01 +0000000010000000_4D800000_00 +FFC00000004007FE_DA7FFFFF_01 +000000000001A359_47D1AC80_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C700040_01 +FFFFFFFFFE62EC20_CBCE89F0_00 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E800000_01 +000000000000285F_46217C00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_CE80001F_01 +FFFFF836F99DBAA8_D4F920CC_01 +0000000100000000_4F800000_00 +00000020003FFEFE_52000100_01 +0033466832042D47_5A4D19A1_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_C4EF2000_00 +00000000003829C8_4A60A720_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_55800000_01 +0000000FB77C672B_517B77C7_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D000400_01 +0000000000001B78_45DBC000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_DB000000_01 +0000000000000071_42E20000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_55A00000_01 +FFFFFFFFFFFFFF86_C2F40000_00 +0000004000000000_52800000_00 +0800000000040800_5D000001_01 +FFF8A60D9E19F17E_D8EB3E4C_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +FFFFFFFFF7506DBA_CD0AF924_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_C7820480_00 +FFFFFFFFFEA42AC9_CBADEA9B_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_55840000_01 +FFE7AA3F2BDACC89_D9C2AE06_01 +0000040000000000_54800000_00 +FFF8040000040000_D8FF7FFF_01 +FFFFFFFFFFFFFFFD_C0400000_00 +0000080000000000_55000000_00 +FFFF80000800001F_D6FFFFEF_01 +FFFDF681DECDADC9_D8025F88_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_D380000F_01 +FFFFFFFFFFFFCFBE_C6410800_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51102000_01 +FEC01FECA24DE1B0_DB9FF009_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_DD000000_01 +F858A66761669936_DCF4EB33_01 +0000800000000000_57000000_00 +FFFEFF800000003E_D7803FFF_01 +F716EA43FAC45C97_DD0E915B_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_C2680000_00 +0024D70EC7661FD8_5A135C3C_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_DE7E0000_01 +FFD956DBD0AEE817_DA1AA490_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FC_01 +FFFFFFFFFFFF4300_C73D0000_00 +0008000000000000_59000000_00 +4000000004002000_5E800001_01 +C12EDF40F41F6021_DE7B4482_01 +0010000000000000_59800000_00 +FF9000000000001D_DADFFFFF_01 +FFFFFFF83DE950F6_D0F842D5_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_DEFFFFF8_01 +FE2B59CB3A604D69_DBEA531A_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5F000000_01 +000000A37C210862_53237C22_01 +0080000000000000_5B000000_00 +0002000002000002_58000001_01 +FFFFB65CD8617789_D693464F_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55E00000_01 +FFFFFFFFFFFFF01D_C57E3000_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800005_01 +000000000D098D19_4D5098D2_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C800000_01 +000006B3BD2C7BEF_54D677A6_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFF00_01 +FFFF4E5ADDDAA4A8_D731A522_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE01_01 +FFFFFFFFFFFFFF21_C35F0000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83C000_01 +FFFFFFFFFC648262_CC66DF67_01 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_DE7FFF80_01 +FFFFFF7353AC45D2_D30CAC53_01 +8000000000000000_DF000000_00 +FFFFFFFFFFE7EFFF_C9C08008_00 +0000000000A1202D_4B21202D_00 +C000000000000000_DE800000_00 +FFFFFFFFFFFF5F7F_C7208100_00 +000000000040CA70_4A8194E0_00 +E000000000000000_DE000000_00 +0000200201FFFFFE_56000808_01 +00000003B55D87D4_506D5762_01 +F000000000000000_DD800000_00 +FF80000DFFFFFFFF_DAFFFFE4_01 +000000010510FAEF_4F82887E_01 +F800000000000000_DD000000_00 +0003FFF00000000F_587FFC01_01 +000000000000724A_46E49400_00 +FC00000000000000_DC800000_00 +FFFFFFDF80000002_D201FFFF_01 +0000000000000064_42C80000_00 +FE00000000000000_DC000000_00 +FEFFFFFFFFF800FE_DB800000_01 +FFFFFFC2C6222702_D274E777_01 +FF00000000000000_DB800000_00 +0000000408000002_50810001_01 +000000E96DF1CB41_53696DF2_01 +FF80000000000000_DB000000_00 +007FFFFFFFFFF9FE_5B000000_01 +F727F174DEE7DC85_DD0D80E8_01 +FFC0000000000000_DA800000_00 +8000000003FFFEFE_DEFFFFFF_01 +FFFFFFFFFFF0BD5B_C9742A50_00 +FFE0000000000000_DA000000_00 +0BEFFFFFFFFFFFFF_5D3F0000_01 +000000000002790C_481E4300_00 +FFF0000000000000_D9800000_00 +FFFFFFFFFFEFFBFA_C9802030_00 +000000169E75DF01_51B4F3AF_01 +FFF8000000000000_D9000000_00 +00000007FEFFDFFF_50FFDFFC_01 +000000000000000E_41600000_00 +FFFC000000000000_D8800000_00 +0003FFFE0007FFFE_587FFF81_01 +FFFFFFFFFFF28622_C9579DE0_00 +FFFE000000000000_D8000000_00 +FFFFFF7FFFFDF7FF_D3000002_01 +00072F0EC496FE21_58E5E1D9_01 +FFFF000000000000_D7800000_00 +DFBFFFFFFFFFFFFE_DE010000_01 +0000000000FC1FCA_4B7C1FCA_00 +FFFF800000000000_D7000000_00 +00000FFF800FFFFE_557FF801_01 +FFFF5194E4A9C2CE_D72E6B1B_01 +FFFFC00000000000_D6800000_00 +00000002100007FD_50040002_01 +FFFFFFFFFFC2D8FE_CA749C08_00 +FFFFE00000000000_D6000000_00 +000000000007FF6E_48FFEDC0_00 +000000000001766E_47BB3700_00 +FFFFF00000000000_D5800000_00 +0040000400000002_5A800009_01 +0000000000007841_46F08200_00 +FFFFF80000000000_D5000000_00 +3DFFFFFFFFFFFF7E_5E780000_01 +FFFFFFE549E17E30_D1D5B0F4_01 +FFFFFC0000000000_D4800000_00 +FFFFFFFFFFFFFEE1_C38F8000_00 +FFFFFFFFFFFFFFE7_C1C80000_00 +FFFFFE0000000000_D4000000_00 +000000000EFFFFDF_4D6FFFFE_01 +FFFFFFFFFFFFFF73_C30D0000_00 +FFFFFF0000000000_D3800000_00 +FD00000008000000_DC3FFFFF_01 +000000000001DBB1_47EDD880_00 +FFFFFF8000000000_D3000000_00 +FFFFFFFFFFF8007F_C8FFF020_00 +FFFFFFFEFD10A515_CF8177AD_01 +FFFFFFC000000000_D2800000_00 +FFEFFFFFFFFFFFFE_D9800000_01 +FAB02984F6283B6C_DCA9FACF_01 +FFFFFFE000000000_D2000000_00 +FFFFFFBC000001FE_D287FFFF_01 +FEB087C6B9FE7FE0_DBA7BC1C_01 +FFFFFFF000000000_D1800000_00 +FFF80001000007FE_D8FFFFDF_01 +00F2762EA6837956_5B72762F_01 +FFFFFFF800000000_D1000000_00 +FFF7E0FFFFFFFFFE_D901F000_01 +00002E1175484626_563845D6_01 +FFFFFFFC00000000_D0800000_00 +0000200020000FFE_56000081_01 +000000000000068F_44D1E000_00 +FFFFFFFE00000000_D0000000_00 +021FFFFFFFFBFFFF_5C080000_01 +FFFFFFFFFFFFFFF9_C0E00000_00 +FFFFFFFF00000000_CF800000_00 +FFFFFFD0000FFFFD_D23FFFC0_01 +000000BDF6658B83_533DF666_01 +FFFFFFFF80000000_CF000000_00 +1000001FFDFFFFFF_5D800001_01 +0000000000003B5B_466D6C00_00 +FFFFFFFFC0000000_CE800000_00 +FFFFFFBFFE0FFFFF_D28003E0_01 +FFFFFFFFFFFFFFF0_C1800000_00 +FFFFFFFFE0000000_CE000000_00 +FFFFFFFBF00007FF_D081FFFF_01 +01E986274F48EAAD_5BF4C314_01 +FFFFFFFFF0000000_CD800000_00 +1FFFFFFDFFFFFF7F_5E000000_01 +FFFFFFFFFFFFCB5A_C6529800_00 +FFFFFFFFF8000000_CD000000_00 +7FF000000000FFFF_5EFFE001_01 +00000003C2717FC3_50709C60_01 +FFFFFFFFFC000000_CC800000_00 +FFFFFFE00008001F_D1FFFFBF_01 +FFFFFFFFFFEFABDA_C982A130_00 +FFFFFFFFFE000000_CC000000_00 +0200000000000002_5C000001_01 +FFFFFFFFF8FDA53F_CCE04B58_01 +FFFFFFFFFF000000_CB800000_00 +F6000003FFFFFFFE_DD1FFFFF_01 +FFFFFFFFFFFFFFD0_C2400000_00 +FFFFFFFFFF800000_CB000000_00 +FFFFFFFFFFBFFF7E_CA800104_00 +00000000EE0FEA62_4F6E0FEB_01 +FFFFFFFFFFC00000_CA800000_00 +0000007FFF9FFFFD_52FFFF40_01 +00000037F35EDC1D_525FCD7C_01 +FFFFFFFFFFE00000_CA000000_00 +FFFFFFF7FDFFFF7D_D1002000_01 +00000000000001AD_43D68000_00 +FFFFFFFFFFF00000_C9800000_00 +FFFFFF0000100020_D37FFFEF_01 +27F167FBC7FC5F9A_5E1FC5A0_01 +FFFFFFFFFFF80000_C9000000_00 +003FFFFFFFFC0001_5A800000_01 +000E48F9F4EBD30E_59648FA0_01 +FFFFFFFFFFFC0000_C8800000_00 +DFFFFFFFFFFBFFFE_DE000000_01 +FC91C23EE8C9424F_DC5B8F70_01 +FFFFFFFFFFFE0000_C8000000_00 +F7DFFBFFFFFFFFFE_DD020040_01 +000000002CAE080C_4E32B821_01 +FFFFFFFFFFFF0000_C7800000_00 +FFFFC00010000020_D67FFFBF_01 +04D921F917B20E40_5C9B2440_01 +FFFFFFFFFFFF8000_C7000000_00 +F8000FFFFFFFFFFD_DCFFFE00_01 +FFF17C566BC7D811_D9683A99_01 +FFFFFFFFFFFFC000_C6800000_00 +00000000000000FE_437E0000_00 +FFF82AC14930D386_D8FAA7D6_01 +FFFFFFFFFFFFE000_C6000000_00 +00000000000003FC_447F0000_00 +000E62EC60E119FC_59662EC7_01 +FFFFFFFFFFFFF000_C5800000_00 +FFFFEFF7FF7FFFFE_D5804004_01 +0E2B1ECF210EEDC5_5D62B1ED_01 +FFFFFFFFFFFFF800_C5000000_00 +00000000007FFF1F_4AFFFE3E_00 +FFFFFE534F5676F7_D3D65854_01 +FFFFFFFFFFFFFC00_C4800000_00 +0000001004FFFFFD_51802800_01 +0000035C939669F1_545724E6_01 +FFFFFFFFFFFFFE00_C4000000_00 +1FFFFFFFFFFFFDFD_5E000000_01 +FFFFFFFFFFFFFF91_C2DE0000_00 +FFFFFFFFFFFFFF00_C3800000_00 +01FFFFFFFBFFEFFE_5C000000_01 +000000000000016E_43B70000_00 +FFFFFFFFFFFFFF80_C3000000_00 +FFF7FFFFFFFFF7FD_D9000000_01 +FFFFF8E2BCFAC553_D4E3A860_01 +FFFFFFFFFFFFFFC0_C2800000_00 +FFFFFBFFFFFE0FFE_D4800000_01 +00000001A4E704BF_4FD27383_01 +FFFFFFFFFFFFFFE0_C2000000_00 +1400007FFFFFFFFD_5DA00004_01 +FFFFFFFC93B187B4_D05B139E_01 +FFFFFFFFFFFFFFF0_C1800000_00 +40000000007FFFFD_5E800001_01 +000000000067D468_4ACFA8D0_00 +FFFFFFFFFFFFFFF8_C1000000_00 +007FFEFFFFFBFFFE_5AFFFE00_01 +FFFFFFE26CEC79F8_D1EC989C_01 +FFFFFFFFFFFFFFFC_C0800000_00 +00FFFFFF000000FF_5B800000_01 +FFFFFFFFE0D3983A_CDF9633E_01 +FFFFFFFFFFFFFFFE_C0000000_00 +00007FFFBFFF7FFE_56FFFF80_01 +FFFFFFFDF4A7088A_D002D63D_01 +FFFFFFFFFFFFFFFF_BF800000_00 +000008000000027E_55000001_01 +000000000000F4E8_4774E800_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFF83FFDF_CAF80042_00 +00000E11407887B2_55611408_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +04000003FFFFFFF6_5C800001_01 +0000000000000513_44A26000_00 +FFFFFFFFFFFFFFF7_C1100000_00 +BFFC00000000003E_DE8007FF_01 +00000008D7BBB75B_510D7BBC_01 +FFFFFFFFFFFFFFEF_C1880000_00 +000FFFFBFFFC0000_597FFFC0_01 +FFFFFFFFFFCD5A23_CA4A9774_00 +FFFFFFFFFFFFFFDF_C2040000_00 +FFBFDFFFBFFFFFFF_DA804000_01 +000000000000007F_42FE0000_00 +FFFFFFFFFFFFFFBF_C2820000_00 +00000007FF800003_50FFF001_01 +000000000002BB02_482EC080_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEE7FF_C78C0080_00 +00264B2B9BAD0DA2_5A192CAF_01 +FFFFFFFFFFFFFEFF_C3808000_00 +0000000000100803_49804018_00 +FF9B1DCB9F857D5E_DAC9C468_01 +FFFFFFFFFFFFFDFF_C4004000_00 +FFFFFFBFFFFFEFEE_D2800000_01 +F6FD7542899C1C6F_DD1028AB_01 +FFFFFFFFFFFFFBFF_C4802000_00 +FF800000004001FF_DAFFFFFF_01 +0000000002BE4932_4C2F924D_01 +FFFFFFFFFFFFF7FF_C5001000_00 +00001004000FFFFE_55802001_01 +FFFFFF9DAA0123E0_D2C4ABFD_01 +FFFFFFFFFFFFEFFF_C5800800_00 +00000001FDFFFDFE_4FFEFFFF_01 +FFFC1C8703B1DCB0_D878DE3F_01 +FFFFFFFFFFFFDFFF_C6000400_00 +FE0FE00000000000_DBF81000_00 +0779ED944A4E2779_5CEF3DB3_01 +FFFFFFFFFFFFBFFF_C6800200_00 +FBFFFE0400000000_DC80003F_01 +0000010127E03666_538093F1_01 +FFFFFFFFFFFF7FFF_C7000100_00 +FFFFF0200000FFFE_D57DFFFF_01 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEFFFF_C7800080_00 +FFEFFE0000080000_D9800FFF_01 +FFFFFFFFFD3354EA_CC332AC5_01 +FFFFFFFFFFFDFFFF_C8000040_00 +003FF0000003FFFE_5A7FC001_01 +0000006375B23F7B_52C6EB65_01 +FFFFFFFFFFFBFFFF_C8800020_00 +000407FFFFFFFFF6_58810000_01 +0000000092117F38_4F121180_01 +FFFFFFFFFFF7FFFF_C9000010_00 +FFFFFFFFFFFF7FFF_C7000100_00 +00000000000008BE_450BE000_00 +FFFFFFFFFFEFFFFF_C9800008_00 +004000020FFFFFFF_5A800005_01 +FFFFB84C2D8BC9CB_D68F67A4_01 +FFFFFFFFFFDFFFFF_CA000004_00 +00FFFFFFFFFFFFFD_5B800000_01 +00000023C2C6F284_520F0B1C_01 +FFFFFFFFFFBFFFFF_CA800002_00 +FFFDDFFFFFFFFFFD_D8080000_01 +00000000746356C4_4EE8C6AE_01 +FFFFFFFFFF7FFFFF_CB000001_00 +010000000000BFFF_5B800001_01 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFEFFFFFF_CB800000_01 +FFFFBF7FFBFFFFFE_D6810008_01 +00000006386CE889_50C70D9E_01 +FFFFFFFFFDFFFFFF_CC000000_01 +F00000F7FFFFFFFF_DD7FFFF0_01 +FFFDFC53090C46A4_D800EB3D_01 +FFFFFFFFFBFFFFFF_CC800000_01 +0000000000800047_4B000047_00 +FFFFFFFFD693872E_CE25B1E3_01 +FFFFFFFFF7FFFFFF_CD000000_01 +000000007FBFFBFF_4EFF7FF8_01 +00000026A7845E35_521A9E12_01 +FFFFFFFFEFFFFFFF_CD800000_01 +FFFFFFDFFFFFFBFD_D2000000_01 +000000001433D14C_4DA19E8B_01 +FFFFFFFFDFFFFFFF_CE000000_01 +0001FFFFFFE0000E_58000000_01 +F0F23E8068D3D84A_DD70DC17_01 +FFFFFFFFBFFFFFFF_CE800000_01 +F7FFBFFFFFFFBFFF_DD000400_01 +FFFFBD29B7459087_D685AC91_01 +FFFFFFFF7FFFFFFF_CF000000_01 +FFFFFFF8FFFFBFFF_D0E00008_01 +FFFFFFFFFFEDDC06_C9911FD0_00 +FFFFFFFEFFFFFFFF_CF800000_01 +FFFFFFF80001FFFF_D0FFFFC0_01 +0000000000002FF9_463FE400_00 +FFFFFFFDFFFFFFFF_D0000000_01 +004000040000FFFF_5A800009_01 +FFFFFFFFFFFFFFF1_C1700000_00 +FFFFFFFBFFFFFFFF_D0800000_01 +C0000000007FFFFA_DE7FFFFF_01 +FFFFFFFFFE053E2B_CBFD60EA_01 +FFFFFFF7FFFFFFFF_D1000000_01 +7FFE000007FFFFFF_5EFFFC01_01 +000000000000000D_41500000_00 +FFFFFFEFFFFFFFFF_D1800000_01 +F80000000001007E_DCFFFFFF_01 +FFFFED48424AD9D6_D595BDED_01 +FFFFFFDFFFFFFFFF_D2000000_01 +FFFFFE0001FEFFFF_D3FFFF00_01 +000000000000013B_439D8000_00 +FFFFFFBFFFFFFFFF_D2800000_01 +0007FBFFFFFDFFFE_58FF8000_01 +4A16BD4128090C83_5E942D7B_01 +FFFFFF7FFFFFFFFF_D3000000_01 +00FFF7FFFF7FFFFE_5B7FF800_01 +0000000000000006_40C00000_00 +FFFFFEFFFFFFFFFF_D3800000_01 +FBFFFFBFFFBFFFFF_DC800008_01 +00000000000001BA_43DD0000_00 +FFFFFDFFFFFFFFFF_D4000000_01 +0000000040000082_4E800002_01 +FF07A2BF5B689F89_DB785D40_01 +FFFFFBFFFFFFFFFF_D4800000_01 +0000001FF8000008_51FFC001_01 +F87CAA7DE672DE8B_DCF06AB0_01 +FFFFF7FFFFFFFFFF_D5000000_01 +07FFF80000000002_5CFFFF01_01 +0000000010A1E5B8_4D850F2E_01 +FFFFEFFFFFFFFFFF_D5800000_01 +F7FFFFE00007FFFF_DD000001_01 +FFFFFFFFFFF6ADFC_C9152040_00 +FFFFDFFFFFFFFFFF_D6000000_01 +FFFFFF03FFFFFFC0_D37C0000_01 +EA579475948F0032_DDAD435C_01 +FFFFBFFFFFFFFFFF_D6800000_01 +FC00000000003FF6_DC7FFFFF_01 +002E677AC313BF60_5A399DEC_01 +FFFF7FFFFFFFFFFF_D7000000_01 +02000007FF7FFFFF_5C000002_01 +0000000E999639F1_51699964_01 +FFFEFFFFFFFFFFFF_D7800000_01 +FFFF83FFFFFFFFBE_D6F80000_01 +000000000001537D_47A9BE80_00 +FFFDFFFFFFFFFFFF_D8000000_01 +EFFFFFC00000003D_DD800001_01 +FFFFFFF21FEDFD35_D15E0120_01 +FFFBFFFFFFFFFFFF_D8800000_01 +FFFFFFF0000007FE_D17FFFFF_01 +FFFFFFFFFFDE0839_CA07DF1C_00 +FFF7FFFFFFFFFFFF_D9000000_01 +0000007FFFE000FF_52FFFFC1_01 +FFFFFFFF79F30F48_CF060CF0_01 +FFEFFFFFFFFFFFFF_D9800000_01 +FFFFFC13FFFFFFFD_D47B0000_01 +0000000000001B85_45DC2800_00 +FFDFFFFFFFFFFFFF_DA000000_01 +000008000007FFFE_55000001_01 +12DB4409E5AE87E6_5D96DA21_01 +FFBFFFFFFFFFFFFF_DA800000_01 +FFFFFFFFFFF7BFEE_C9040120_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FF7FFFFFFFFFFFFF_DB000000_01 +000000001040FFFE_4D820800_01 +00000909A09C13D3_55109A0A_01 +FEFFFFFFFFFFFFFF_DB800000_01 +FFFFFF01FFFFFF7F_D37E0000_01 +FFFFFF72E7D2575D_D30D182D_01 +FDFFFFFFFFFFFFFF_DC000000_01 +FFFFFFFFFFFEFFDB_C7801280_00 +0000000000000017_41B80000_00 +FBFFFFFFFFFFFFFF_DC800000_01 +100000001FFFFFF6_5D800001_01 +000000114B12EF51_518A5898_01 +F7FFFFFFFFFFFFFF_DD000000_01 +0407FFFFFFFFFEFF_5C810000_01 +FFFFFF769F3A5C2C_D30960C5_01 +EFFFFFFFFFFFFFFF_DD800000_01 +FFFFFFFDF7FFFFFD_D0020000_01 +FFFFFFFFFFFFFFF2_C1600000_00 +DFFFFFFFFFFFFFFF_DE000000_01 +FFFFFFFFFE0007FF_CBFFFC00_01 +000000000000001E_41F00000_00 +BFFFFFFFFFFFFFFF_DE800000_01 +FFF800000009FFFF_D8FFFFFF_01 +0000000000007AA4_46F54800_00 +7FFFFFFFFFFFFFFF_5F000000_01 +4080000000FFFFFF_5E810001_01 +000000000DE7601D_4D5E7602_01 +3FFFFFFFFFFFFFFF_5E800000_01 +FFCFFFFFFFBFFFFE_DA400000_01 +FFFFFFFFFFFFFFCA_C2580000_00 +1FFFFFFFFFFFFFFF_5E000000_01 +000080400000003F_57004001_01 +00000000001F75A5_49FBAD28_00 +0FFFFFFFFFFFFFFF_5D800000_01 +FFFFFFEFFFFFCFFE_D1800001_01 +FFFFFEE775887420_D38C453B_01 +07FFFFFFFFFFFFFF_5D000000_01 +00000000000801FE_49001FE0_00 +0000000000213FF1_4A04FFC4_00 +03FFFFFFFFFFFFFF_5C800000_01 +07FEFFFFFFFFFFEE_5CFFE000_01 +0000000000000004_40800000_00 +01FFFFFFFFFFFFFF_5C000000_01 +0000000820000003_51020001_01 +FFFFFFF9AD105214_D0CA5DF5_01 +00FFFFFFFFFFFFFF_5B800000_01 +FFFFF00FFFFFFFBE_D57F0000_01 +FFFFFFFFFFCC48E7_CA4EDC64_00 +007FFFFFFFFFFFFF_5B000000_01 +00000FFFEF7FFFFF_557FFEF8_01 +FFFFFFFFFF0BA6CB_CB745935_00 +003FFFFFFFFFFFFF_5A800000_01 +FFFFFF7FBFFFFFBF_D3004000_01 +FFFFFFFFFFF24425_C95BBDB0_00 +001FFFFFFFFFFFFF_5A000000_01 +200000001FFBFFFF_5E000001_01 +FFFFFF4E7115EC53_D3318EEA_01 +000FFFFFFFFFFFFF_59800000_01 +FFFFF803FFFFFFBF_D4FF8000_01 +FFFFFC2E539ADCFE_D4746B19_01 +0007FFFFFFFFFFFF_59000000_01 +FFFFFFFFFBFFFFFF_CC800000_01 +00000055084732F3_52AA108F_01 +0003FFFFFFFFFFFF_58800000_01 +BFFF7FFFFFFFFE00_DE800100_01 +FFFFFFFFFFFF8543_C6F57A00_00 +0001FFFFFFFFFFFF_58000000_01 +0000001FFBFFE000_51FFDFFF_00 +FFFFFFFFFFFE491B_C7DB7280_00 +0000FFFFFFFFFFFF_57800000_01 +FC00200000001FFE_DC7FF7FF_01 +FFFFF16898822A24_D5697677_01 +00007FFFFFFFFFFF_57000000_01 +3FFF03FFFFFFFFFE_5E7FFC10_01 +FFFFFF8FFE18C7BF_D2E003CE_01 +00003FFFFFFFFFFF_56800000_01 +FFFFFEFFFEFFFFFD_D3800080_01 +00F03620C1266ED9_5B703621_01 +00001FFFFFFFFFFF_56000000_01 +BF7EFFFFFFFFFFFF_DE810200_01 +FFFFFFFFFFFFFFD5_C22C0000_00 +00000FFFFFFFFFFF_55800000_01 +FFFBFFFFF803FFFE_D8800000_01 +0000000000068684_48D0D080_00 +000007FFFFFFFFFF_55000000_01 +DFFFFFE00000001E_DE000000_01 +FFFFFFFFFFFFECF5_C5985800_00 +000003FFFFFFFFFF_54800000_01 +FFFF00400000FFFF_D77FBFFF_01 +0000000000000002_40000000_00 +000001FFFFFFFFFF_54000000_01 +FBFFFFFFFFFFBDFE_DC800000_01 +0000000000000BC9_453C9000_00 +000000FFFFFFFFFF_53800000_01 +807FFFFFFFFFDFFE_DEFF0000_01 +FFC274E35A70CD76_DA762C72_01 +0000007FFFFFFFFF_53000000_01 +0FFFFFFFFEFFFFFD_5D800000_01 +FFFFFFFF00E73AFC_CF7F18C5_01 +0000003FFFFFFFFF_52800000_01 +FFC000000001000E_DA7FFFFF_01 +FFFFFFFFFFFE15E9_C7F50B80_00 +0000001FFFFFFFFF_52000000_01 +0001FFFFFFFFF3FD_58000000_01 +0000000000000033_424C0000_00 +0000000FFFFFFFFF_51800000_01 +000000001FFFBFFF_4DFFFE00_01 +FFFFFFEE6B141E1B_D18CA75F_01 +00000007FFFFFFFF_51000000_01 +FFFFFFFFF60007FF_CD1FFF80_01 +00000001AB310BA6_4FD59886_01 +00000003FFFFFFFF_50800000_01 +0003FFFFB7FFFFFF_587FFFEE_01 +FFFFFFFFFFFFF195_C566B000_00 +00000001FFFFFFFF_50000000_01 +FFFFFFFF8000000B_CEFFFFFF_01 +00000019BA8D5559_51CDD46B_01 +00000000FFFFFFFF_4F800000_01 +FBFEFFFFFFFFFFF9_DC802000_01 +FFFFFFB6F062822D_D2921F3A_01 +000000007FFFFFFF_4F000000_01 +0001000000000082_57800001_01 +01CEAD9E2FB104A4_5BE756D0_01 +000000003FFFFFFF_4E800000_01 +000003FFFFFFFF7C_54800000_01 +FFFFFFFFFD681E78_CC25F862_00 +000000001FFFFFFF_4E000000_01 +00002000400001FF_56000101_01 +0000000000000018_41C00000_00 +000000000FFFFFFF_4D800000_01 +3FFF80000000003E_5E7FFE01_01 +FFFFFFFFFFFFFF95_C2D60000_00 +0000000007FFFFFF_4D000000_01 +010000BFFFFFFFFF_5B800060_01 +0000001697087B19_51B4B844_01 +0000000003FFFFFF_4C800000_01 +FBFFFFFFFFEEFFFD_DC800000_01 +0000000E64BDFC55_51664BE0_01 +0000000001FFFFFF_4C000000_01 +FC00000001FFFFFE_DC7FFFFF_01 +FFFED156A62AB849_D79754AC_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_D0F80200_01 +00015354EAE7C259_57A9AA76_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFF0F4DF3C75_D170B20C_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_D8BFFFFF_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_CB0001C0_00 +FFFFFFDB5433CB9B_D212AF30_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_D4000800_01 +FFFFFFFFFFDEAE1F_CA054784_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_CD7F7FFF_01 +FFFFFFFE7735DEC7_CFC46510_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFE0000_01 +000003757D8B12ED_545D5F63_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_D3FC0400_01 +00000A654064E046_55265407_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000001_01 +FFFFFFFFFFFFFFE7_C1C80000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5D000000_01 +FFFFAD78B3D6C3B6_D6A50E98_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +FFFFFFF70B77F34F_D10F4880_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_D2FFFF20_01 +0000013EB4D67EC8_539F5A6C_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_DE800040_01 +0005CEAF34EA1DC7_58B9D5E7_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900001_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000360D0_48583400_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B802000_01 +00C000708FF1BA51_5B400071_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_DCFFBFFF_01 +0F9E07DCC0BDC061_5D79E07E_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC001_01 +FFFFFFE1B9B2A079_D1F2326A_01 +000000000000003F_427C0000_00 +FFF80000000080FF_D8FFFFFF_01 +00000000001EB5B4_49F5ADA0_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +00000000005AC607_4AB58C0E_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_CF83FFFF_01 +000005C5B9D66984_54B8B73B_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_DE7FF800_01 +00001D06B372AA06_55E8359C_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f32_rz.tv b/wally-pipelined/testbench/fp/i64_f32_rz.tv index b996cbb7a..bdcd197ed 100644 --- a/wally-pipelined/testbench/fp/i64_f32_rz.tv +++ b/wally-pipelined/testbench/fp/i64_f32_rz.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 5CFFFFBF_01 -0000000032CC8B7A 4E4B322D_01 -0000000000000000 00000000_00 -FFFFFFFFC0003FFE CE7FFF00_01 -032C857F319EDE38 5C4B215F_01 -0000000000000001 3F800000_00 -FFFFFBFFFFF8003E D4800000_01 -00394C79B6D3007B 5A6531E6_01 -0000000000000002 40000000_00 -FBFFFFF0000001FF DC800001_01 -0000000001AE458D 4BD722C6_01 -0000000000000004 40800000_00 -00040008000007FE 58800100_01 -F9EB456140D88764 DCC29753_01 -0000000000000008 41000000_00 -FFFFE400FFFFFFFE D5DFF800_01 -07DE834A248EDF36 5CFBD069_01 -0000000000000010 41800000_00 -00000003FF001FFF 507FC007_01 -FFFFFFFFFFE385E2 C9E3D0F0_00 -0000000000000020 42000000_00 -F0041FFFFFFFFFFF DD7FBE00_01 -000000059EB1FD45 50B3D63F_01 -0000000000000040 42800000_00 -FFFFFFFFFFFCFFF9 C84001C0_00 -FFFFFFFFFFFEDDFE C7910100_00 -0000000000000080 43000000_00 -000000000003FF00 487FC000_00 -00000000C89FF56B 4F489FF5_01 -0000000000000100 43800000_00 -000FFFFF7FDFFFFF 597FFFF7_01 -1B5E4F0BE0DEBFF0 5DDAF278_01 -0000000000000200 44000000_00 -FFFDF803FFFFFFFF D801FF00_01 -FFFFFFFFFFF4766B C9389950_00 -0000000000000400 44800000_00 -0000080100000FFE 55001000_01 -000000000000000C 41400000_00 -0000000000000800 45000000_00 -0048000000100000 5A900000_01 -FFE662A109109D0A D9CCEAF7_01 -0000000000001000 45800000_00 -C000000037FFFFFE DE7FFFFF_01 -FFFFFFFFFFFFFFE4 C1E00000_00 -0000000000002000 46000000_00 -F801000000100000 DCFFDFFF_01 -FE114B79075F70EE DBF75A43_01 -0000000000004000 46800000_00 -100000000001003E 5D800000_01 -00000000000003AC 446B0000_00 -0000000000008000 47000000_00 -200000FFFFFFF800 5E000003_01 -00000044A3A3DBE5 52894747_01 -0000000000010000 47800000_00 -FFE0003EFFFFFFFF D9FFFE08_01 -FFFFFFFFFFFF1A91 C7656F00_00 -0000000000020000 48000000_00 -FFFFF7C3FFFFFFFD D503C000_01 -0000000000003309 464C2400_00 -0000000000040000 48800000_00 -000083FFF7FFFFFE 5703FFF7_01 -FFFFFFFFFFFFFF58 C3280000_00 -0000000000080000 49000000_00 -FFFFFFDE01FFFFFE D207F800_01 -0000000000002980 46260000_00 -0000000000100000 49800000_00 -00000000FFF07FFF 4F7FF07F_01 -000000000000005D 42BA0000_00 -0000000000200000 4A000000_00 -000020FFDFFFFFFF 5603FF7F_01 -FFFC8C23DA2CEAD8 D85CF709_01 -0000000000400000 4A800000_00 -E0000000003FFFDF DDFFFFFF_01 -FFFFFDE3C1DEC43C D4070F88_01 -0000000000800000 4B000000_00 -FFFF00000BFFFFFD D77FFFF4_01 -000000000030FFBE 4A43FEF8_00 -0000000001000000 4B800000_00 -FFFE000007FFEFFD D7FFFFFC_01 -FFFFFFFFEFDEED86 CD810893_01 -0000000002000000 4C000000_00 -F3FFFFFFFFBFFFFE DD400000_01 -000000001DA3FF45 4DED1FFA_01 -0000000004000000 4C800000_00 -FFFFFFFF00010007 CF7FFEFF_01 -FFFFFFFE9B1BCB54 CFB2721A_01 -0000000008000000 4D000000_00 -00004000004001FE 56800000_01 -F27DD19DE6563714 DD5822E6_01 -0000000010000000 4D800000_00 -FFC00000004007FE DA7FFFFF_01 -000000000001A359 47D1AC80_00 -0000000020000000 4E000000_00 -0000000003C000FE 4C70003F_01 -FFFFFFFFFE62EC20 CBCE89F0_00 -0000000040000000 4E800000_00 -000000003FFFFFFD 4E7FFFFF_01 -000000000000285F 46217C00_00 -0000000080000000 4F000000_00 -FFFFFFFFBFFFF00F CE80001F_01 -FFFFF836F99DBAA8 D4F920CC_01 -0000000100000000 4F800000_00 -00000020003FFEFE 520000FF_01 -0033466832042D47 5A4D19A0_01 -0000000200000000 50000000_00 -FFFFFFFFFFFFF887 C4EF2000_00 -00000000003829C8 4A60A720_00 -0000000400000000 50800000_00 -00000FFFFFFF7DFD 557FFFFF_01 -0000000FB77C672B 517B77C6_01 -0000000800000000 51000000_00 -08003FFDFFFFFFFE 5D0003FF_01 -0000000000001B78 45DBC000_00 -0000001000000000 51800000_00 -FF7FFFFFFFEFDFFF DB000000_01 -0000000000000071 42E20000_00 -0000002000000000 52000000_00 -000013FFFFFFFDFF 559FFFFF_01 -FFFFFFFFFFFFFF86 C2F40000_00 -0000004000000000 52800000_00 -0800000000040800 5D000000_01 -FFF8A60D9E19F17E D8EB3E4C_01 -0000008000000000 53000000_00 -000077FFF0000000 56EFFFE0_00 -FFFFFFFFF7506DBA CD0AF924_01 -0000010000000000 53800000_00 -FFFFFFFFFFFEFBF7 C7820480_00 -FFFFFFFFFEA42AC9 CBADEA9B_01 -0000020000000000 54000000_00 -0000107FFFFFDFFD 5583FFFF_01 -FFE7AA3F2BDACC89 D9C2AE06_01 -0000040000000000 54800000_00 -FFF8040000040000 D8FF7FFF_01 -FFFFFFFFFFFFFFFD C0400000_00 -0000080000000000 55000000_00 -FFFF80000800001F D6FFFFEF_01 -FFFDF681DECDADC9 D8025F88_01 -0000100000000000 55800000_00 -FFFFFEFFFFE0007F D380000F_01 -FFFFFFFFFFFFCFBE C6410800_00 -0000200000000000 56000000_00 -0000000901FFFFFD 51101FFF_01 -FEC01FECA24DE1B0 DB9FF009_01 -0000400000000000 56800000_00 -F7FFFFFFDFFF7FFF DD000000_01 -F858A66761669936 DCF4EB33_01 -0000800000000000 57000000_00 -FFFEFF800000003E D7803FFF_01 -F716EA43FAC45C97 DD0E915B_01 -0001000000000000 57800000_00 -FFFFFFFFFFFFFFC6 C2680000_00 -0024D70EC7661FD8 5A135C3B_01 -0002000000000000 58000000_00 -C07FFFFFFFFFFFFE DE7E0000_01 -FFD956DBD0AEE817 DA1AA490_01 -0004000000000000 58800000_00 -020003EFFFFFFFFE 5C0000FB_01 -FFFFFFFFFFFF4300 C73D0000_00 -0008000000000000 59000000_00 -4000000004002000 5E800000_01 -C12EDF40F41F6021 DE7B4482_01 -0010000000000000 59800000_00 -FF9000000000001D DADFFFFF_01 -FFFFFFF83DE950F6 D0F842D5_01 -0020000000000000 5A000000_00 -800003FFFFFC0000 DEFFFFF8_01 -FE2B59CB3A604D69 DBEA531A_01 -0040000000000000 5A800000_00 -7FFFFFFDFFFFBFFF 5EFFFFFF_01 -000000A37C210862 53237C21_01 -0080000000000000 5B000000_00 -0002000002000002 58000000_01 -FFFFB65CD8617789 D693464F_01 -0100000000000000 5B800000_00 -00001BFFFFFFBFFE 55DFFFFF_01 -FFFFFFFFFFFFF01D C57E3000_00 -0200000000000000 5C000000_00 -1000008000003FFF 5D800004_01 -000000000D098D19 4D5098D1_01 -0400000000000000 5C800000_00 -03FFFFFFFFFFF5FF 5C7FFFFF_01 -000006B3BD2C7BEF 54D677A5_01 -0800000000000000 5D000000_00 -00003FFFBFFFFFFE 567FFEFF_01 -FFFF4E5ADDDAA4A8 D731A522_01 -1000000000000000 5D800000_00 -001FFFC000000FFD 59FFFE00_01 -FFFFFFFFFFFFFF21 C35F0000_00 -2000000000000000 5E000000_00 -0000000041DFFFFF 4E83BFFF_01 -FFFFFFFFFC648262 CC66DF67_01 -4000000000000000 5E800000_00 -C0001FFFFFFFFFFB DE7FFF80_01 -FFFFFF7353AC45D2 D30CAC53_01 -8000000000000000 DF000000_00 -FFFFFFFFFFE7EFFF C9C08008_00 -0000000000A1202D 4B21202D_00 -C000000000000000 DE800000_00 -FFFFFFFFFFFF5F7F C7208100_00 -000000000040CA70 4A8194E0_00 -E000000000000000 DE000000_00 -0000200201FFFFFE 56000807_01 -00000003B55D87D4 506D5761_01 -F000000000000000 DD800000_00 -FF80000DFFFFFFFF DAFFFFE4_01 -000000010510FAEF 4F82887D_01 -F800000000000000 DD000000_00 -0003FFF00000000F 587FFC00_01 -000000000000724A 46E49400_00 -FC00000000000000 DC800000_00 -FFFFFFDF80000002 D201FFFF_01 -0000000000000064 42C80000_00 -FE00000000000000 DC000000_00 -FEFFFFFFFFF800FE DB800000_01 -FFFFFFC2C6222702 D274E777_01 -FF00000000000000 DB800000_00 -0000000408000002 50810000_01 -000000E96DF1CB41 53696DF1_01 -FF80000000000000 DB000000_00 -007FFFFFFFFFF9FE 5AFFFFFF_01 -F727F174DEE7DC85 DD0D80E8_01 -FFC0000000000000 DA800000_00 -8000000003FFFEFE DEFFFFFF_01 -FFFFFFFFFFF0BD5B C9742A50_00 -FFE0000000000000 DA000000_00 -0BEFFFFFFFFFFFFF 5D3EFFFF_01 -000000000002790C 481E4300_00 -FFF0000000000000 D9800000_00 -FFFFFFFFFFEFFBFA C9802030_00 -000000169E75DF01 51B4F3AE_01 -FFF8000000000000 D9000000_00 -00000007FEFFDFFF 50FFDFFB_01 -000000000000000E 41600000_00 -FFFC000000000000 D8800000_00 -0003FFFE0007FFFE 587FFF80_01 -FFFFFFFFFFF28622 C9579DE0_00 -FFFE000000000000 D8000000_00 -FFFFFF7FFFFDF7FF D3000002_01 -00072F0EC496FE21 58E5E1D8_01 -FFFF000000000000 D7800000_00 -DFBFFFFFFFFFFFFE DE010000_01 -0000000000FC1FCA 4B7C1FCA_00 -FFFF800000000000 D7000000_00 -00000FFF800FFFFE 557FF800_01 -FFFF5194E4A9C2CE D72E6B1B_01 -FFFFC00000000000 D6800000_00 -00000002100007FD 50040001_01 -FFFFFFFFFFC2D8FE CA749C08_00 -FFFFE00000000000 D6000000_00 -000000000007FF6E 48FFEDC0_00 -000000000001766E 47BB3700_00 -FFFFF00000000000 D5800000_00 -0040000400000002 5A800008_01 -0000000000007841 46F08200_00 -FFFFF80000000000 D5000000_00 -3DFFFFFFFFFFFF7E 5E77FFFF_01 -FFFFFFE549E17E30 D1D5B0F4_01 -FFFFFC0000000000 D4800000_00 -FFFFFFFFFFFFFEE1 C38F8000_00 -FFFFFFFFFFFFFFE7 C1C80000_00 -FFFFFE0000000000 D4000000_00 -000000000EFFFFDF 4D6FFFFD_01 -FFFFFFFFFFFFFF73 C30D0000_00 -FFFFFF0000000000 D3800000_00 -FD00000008000000 DC3FFFFF_01 -000000000001DBB1 47EDD880_00 -FFFFFF8000000000 D3000000_00 -FFFFFFFFFFF8007F C8FFF020_00 -FFFFFFFEFD10A515 CF8177AD_01 -FFFFFFC000000000 D2800000_00 -FFEFFFFFFFFFFFFE D9800000_01 -FAB02984F6283B6C DCA9FACF_01 -FFFFFFE000000000 D2000000_00 -FFFFFFBC000001FE D287FFFF_01 -FEB087C6B9FE7FE0 DBA7BC1C_01 -FFFFFFF000000000 D1800000_00 -FFF80001000007FE D8FFFFDF_01 -00F2762EA6837956 5B72762E_01 -FFFFFFF800000000 D1000000_00 -FFF7E0FFFFFFFFFE D901F000_01 -00002E1175484626 563845D5_01 -FFFFFFFC00000000 D0800000_00 -0000200020000FFE 56000080_01 -000000000000068F 44D1E000_00 -FFFFFFFE00000000 D0000000_00 -021FFFFFFFFBFFFF 5C07FFFF_01 -FFFFFFFFFFFFFFF9 C0E00000_00 -FFFFFFFF00000000 CF800000_00 -FFFFFFD0000FFFFD D23FFFC0_01 -000000BDF6658B83 533DF665_01 -FFFFFFFF80000000 CF000000_00 -1000001FFDFFFFFF 5D800000_01 -0000000000003B5B 466D6C00_00 -FFFFFFFFC0000000 CE800000_00 -FFFFFFBFFE0FFFFF D28003E0_01 -FFFFFFFFFFFFFFF0 C1800000_00 -FFFFFFFFE0000000 CE000000_00 -FFFFFFFBF00007FF D081FFFF_01 -01E986274F48EAAD 5BF4C313_01 -FFFFFFFFF0000000 CD800000_00 -1FFFFFFDFFFFFF7F 5DFFFFFF_01 -FFFFFFFFFFFFCB5A C6529800_00 -FFFFFFFFF8000000 CD000000_00 -7FF000000000FFFF 5EFFE000_01 -00000003C2717FC3 50709C5F_01 -FFFFFFFFFC000000 CC800000_00 -FFFFFFE00008001F D1FFFFBF_01 -FFFFFFFFFFEFABDA C982A130_00 -FFFFFFFFFE000000 CC000000_00 -0200000000000002 5C000000_01 -FFFFFFFFF8FDA53F CCE04B58_01 -FFFFFFFFFF000000 CB800000_00 -F6000003FFFFFFFE DD1FFFFF_01 -FFFFFFFFFFFFFFD0 C2400000_00 -FFFFFFFFFF800000 CB000000_00 -FFFFFFFFFFBFFF7E CA800104_00 -00000000EE0FEA62 4F6E0FEA_01 -FFFFFFFFFFC00000 CA800000_00 -0000007FFF9FFFFD 52FFFF3F_01 -00000037F35EDC1D 525FCD7B_01 -FFFFFFFFFFE00000 CA000000_00 -FFFFFFF7FDFFFF7D D1002000_01 -00000000000001AD 43D68000_00 -FFFFFFFFFFF00000 C9800000_00 -FFFFFF0000100020 D37FFFEF_01 -27F167FBC7FC5F9A 5E1FC59F_01 -FFFFFFFFFFF80000 C9000000_00 -003FFFFFFFFC0001 5A7FFFFF_01 -000E48F9F4EBD30E 59648F9F_01 -FFFFFFFFFFFC0000 C8800000_00 -DFFFFFFFFFFBFFFE DE000000_01 -FC91C23EE8C9424F DC5B8F70_01 -FFFFFFFFFFFE0000 C8000000_00 -F7DFFBFFFFFFFFFE DD020040_01 -000000002CAE080C 4E32B820_01 -FFFFFFFFFFFF0000 C7800000_00 -FFFFC00010000020 D67FFFBF_01 -04D921F917B20E40 5C9B243F_01 -FFFFFFFFFFFF8000 C7000000_00 -F8000FFFFFFFFFFD DCFFFE00_01 -FFF17C566BC7D811 D9683A99_01 -FFFFFFFFFFFFC000 C6800000_00 -00000000000000FE 437E0000_00 -FFF82AC14930D386 D8FAA7D6_01 -FFFFFFFFFFFFE000 C6000000_00 -00000000000003FC 447F0000_00 -000E62EC60E119FC 59662EC6_01 -FFFFFFFFFFFFF000 C5800000_00 -FFFFEFF7FF7FFFFE D5804004_01 -0E2B1ECF210EEDC5 5D62B1EC_01 -FFFFFFFFFFFFF800 C5000000_00 -00000000007FFF1F 4AFFFE3E_00 -FFFFFE534F5676F7 D3D65854_01 -FFFFFFFFFFFFFC00 C4800000_00 -0000001004FFFFFD 518027FF_01 -0000035C939669F1 545724E5_01 -FFFFFFFFFFFFFE00 C4000000_00 -1FFFFFFFFFFFFDFD 5DFFFFFF_01 -FFFFFFFFFFFFFF91 C2DE0000_00 -FFFFFFFFFFFFFF00 C3800000_00 -01FFFFFFFBFFEFFE 5BFFFFFF_01 -000000000000016E 43B70000_00 -FFFFFFFFFFFFFF80 C3000000_00 -FFF7FFFFFFFFF7FD D9000000_01 -FFFFF8E2BCFAC553 D4E3A860_01 -FFFFFFFFFFFFFFC0 C2800000_00 -FFFFFBFFFFFE0FFE D4800000_01 -00000001A4E704BF 4FD27382_01 -FFFFFFFFFFFFFFE0 C2000000_00 -1400007FFFFFFFFD 5DA00003_01 -FFFFFFFC93B187B4 D05B139E_01 -FFFFFFFFFFFFFFF0 C1800000_00 -40000000007FFFFD 5E800000_01 -000000000067D468 4ACFA8D0_00 -FFFFFFFFFFFFFFF8 C1000000_00 -007FFEFFFFFBFFFE 5AFFFDFF_01 -FFFFFFE26CEC79F8 D1EC989C_01 -FFFFFFFFFFFFFFFC C0800000_00 -00FFFFFF000000FF 5B7FFFFF_01 -FFFFFFFFE0D3983A CDF9633E_01 -FFFFFFFFFFFFFFFE C0000000_00 -00007FFFBFFF7FFE 56FFFF7F_01 -FFFFFFFDF4A7088A D002D63D_01 -FFFFFFFFFFFFFFFF BF800000_00 -000008000000027E 55000000_01 -000000000000F4E8 4774E800_00 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFF83FFDF CAF80042_00 -00000E11407887B2 55611407_01 -FFFFFFFFFFFFFFFB C0A00000_00 -04000003FFFFFFF6 5C800000_01 -0000000000000513 44A26000_00 -FFFFFFFFFFFFFFF7 C1100000_00 -BFFC00000000003E DE8007FF_01 -00000008D7BBB75B 510D7BBB_01 -FFFFFFFFFFFFFFEF C1880000_00 -000FFFFBFFFC0000 597FFFBF_01 -FFFFFFFFFFCD5A23 CA4A9774_00 -FFFFFFFFFFFFFFDF C2040000_00 -FFBFDFFFBFFFFFFF DA804000_01 -000000000000007F 42FE0000_00 -FFFFFFFFFFFFFFBF C2820000_00 -00000007FF800003 50FFF000_01 -000000000002BB02 482EC080_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEE7FF C78C0080_00 -00264B2B9BAD0DA2 5A192CAE_01 -FFFFFFFFFFFFFEFF C3808000_00 -0000000000100803 49804018_00 -FF9B1DCB9F857D5E DAC9C468_01 -FFFFFFFFFFFFFDFF C4004000_00 -FFFFFFBFFFFFEFEE D2800000_01 -F6FD7542899C1C6F DD1028AB_01 -FFFFFFFFFFFFFBFF C4802000_00 -FF800000004001FF DAFFFFFF_01 -0000000002BE4932 4C2F924C_01 -FFFFFFFFFFFFF7FF C5001000_00 -00001004000FFFFE 55802000_01 -FFFFFF9DAA0123E0 D2C4ABFD_01 -FFFFFFFFFFFFEFFF C5800800_00 -00000001FDFFFDFE 4FFEFFFE_01 -FFFC1C8703B1DCB0 D878DE3F_01 -FFFFFFFFFFFFDFFF C6000400_00 -FE0FE00000000000 DBF81000_00 -0779ED944A4E2779 5CEF3DB2_01 -FFFFFFFFFFFFBFFF C6800200_00 -FBFFFE0400000000 DC80003F_01 -0000010127E03666 538093F0_01 -FFFFFFFFFFFF7FFF C7000100_00 -FFFFF0200000FFFE D57DFFFF_01 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFFFFFFEFFFF C7800080_00 -FFEFFE0000080000 D9800FFF_01 -FFFFFFFFFD3354EA CC332AC5_01 -FFFFFFFFFFFDFFFF C8000040_00 -003FF0000003FFFE 5A7FC000_01 -0000006375B23F7B 52C6EB64_01 -FFFFFFFFFFFBFFFF C8800020_00 -000407FFFFFFFFF6 5880FFFF_01 -0000000092117F38 4F12117F_01 -FFFFFFFFFFF7FFFF C9000010_00 -FFFFFFFFFFFF7FFF C7000100_00 -00000000000008BE 450BE000_00 -FFFFFFFFFFEFFFFF C9800008_00 -004000020FFFFFFF 5A800004_01 -FFFFB84C2D8BC9CB D68F67A4_01 -FFFFFFFFFFDFFFFF CA000004_00 -00FFFFFFFFFFFFFD 5B7FFFFF_01 -00000023C2C6F284 520F0B1B_01 -FFFFFFFFFFBFFFFF CA800002_00 -FFFDDFFFFFFFFFFD D8080000_01 -00000000746356C4 4EE8C6AD_01 -FFFFFFFFFF7FFFFF CB000001_00 -010000000000BFFF 5B800000_01 -FFFFFFFFFFFFFFFD C0400000_00 -FFFFFFFFFEFFFFFF CB800000_01 -FFFFBF7FFBFFFFFE D6810008_01 -00000006386CE889 50C70D9D_01 -FFFFFFFFFDFFFFFF CC000000_01 -F00000F7FFFFFFFF DD7FFFF0_01 -FFFDFC53090C46A4 D800EB3D_01 -FFFFFFFFFBFFFFFF CC800000_01 -0000000000800047 4B000047_00 -FFFFFFFFD693872E CE25B1E3_01 -FFFFFFFFF7FFFFFF CD000000_01 -000000007FBFFBFF 4EFF7FF7_01 -00000026A7845E35 521A9E11_01 -FFFFFFFFEFFFFFFF CD800000_01 -FFFFFFDFFFFFFBFD D2000000_01 -000000001433D14C 4DA19E8A_01 -FFFFFFFFDFFFFFFF CE000000_01 -0001FFFFFFE0000E 57FFFFFF_01 -F0F23E8068D3D84A DD70DC17_01 -FFFFFFFFBFFFFFFF CE800000_01 -F7FFBFFFFFFFBFFF DD000400_01 -FFFFBD29B7459087 D685AC91_01 -FFFFFFFF7FFFFFFF CF000000_01 -FFFFFFF8FFFFBFFF D0E00008_01 -FFFFFFFFFFEDDC06 C9911FD0_00 -FFFFFFFEFFFFFFFF CF800000_01 -FFFFFFF80001FFFF D0FFFFC0_01 -0000000000002FF9 463FE400_00 -FFFFFFFDFFFFFFFF D0000000_01 -004000040000FFFF 5A800008_01 -FFFFFFFFFFFFFFF1 C1700000_00 -FFFFFFFBFFFFFFFF D0800000_01 -C0000000007FFFFA DE7FFFFF_01 -FFFFFFFFFE053E2B CBFD60EA_01 -FFFFFFF7FFFFFFFF D1000000_01 -7FFE000007FFFFFF 5EFFFC00_01 -000000000000000D 41500000_00 -FFFFFFEFFFFFFFFF D1800000_01 -F80000000001007E DCFFFFFF_01 -FFFFED48424AD9D6 D595BDED_01 -FFFFFFDFFFFFFFFF D2000000_01 -FFFFFE0001FEFFFF D3FFFF00_01 -000000000000013B 439D8000_00 -FFFFFFBFFFFFFFFF D2800000_01 -0007FBFFFFFDFFFE 58FF7FFF_01 -4A16BD4128090C83 5E942D7A_01 -FFFFFF7FFFFFFFFF D3000000_01 -00FFF7FFFF7FFFFE 5B7FF7FF_01 -0000000000000006 40C00000_00 -FFFFFEFFFFFFFFFF D3800000_01 -FBFFFFBFFFBFFFFF DC800008_01 -00000000000001BA 43DD0000_00 -FFFFFDFFFFFFFFFF D4000000_01 -0000000040000082 4E800001_01 -FF07A2BF5B689F89 DB785D40_01 -FFFFFBFFFFFFFFFF D4800000_01 -0000001FF8000008 51FFC000_01 -F87CAA7DE672DE8B DCF06AB0_01 -FFFFF7FFFFFFFFFF D5000000_01 -07FFF80000000002 5CFFFF00_01 -0000000010A1E5B8 4D850F2D_01 -FFFFEFFFFFFFFFFF D5800000_01 -F7FFFFE00007FFFF DD000001_01 -FFFFFFFFFFF6ADFC C9152040_00 -FFFFDFFFFFFFFFFF D6000000_01 -FFFFFF03FFFFFFC0 D37C0000_01 -EA579475948F0032 DDAD435C_01 -FFFFBFFFFFFFFFFF D6800000_01 -FC00000000003FF6 DC7FFFFF_01 -002E677AC313BF60 5A399DEB_01 -FFFF7FFFFFFFFFFF D7000000_01 -02000007FF7FFFFF 5C000001_01 -0000000E999639F1 51699963_01 -FFFEFFFFFFFFFFFF D7800000_01 -FFFF83FFFFFFFFBE D6F80000_01 -000000000001537D 47A9BE80_00 -FFFDFFFFFFFFFFFF D8000000_01 -EFFFFFC00000003D DD800001_01 -FFFFFFF21FEDFD35 D15E0120_01 -FFFBFFFFFFFFFFFF D8800000_01 -FFFFFFF0000007FE D17FFFFF_01 -FFFFFFFFFFDE0839 CA07DF1C_00 -FFF7FFFFFFFFFFFF D9000000_01 -0000007FFFE000FF 52FFFFC0_01 -FFFFFFFF79F30F48 CF060CF0_01 -FFEFFFFFFFFFFFFF D9800000_01 -FFFFFC13FFFFFFFD D47B0000_01 -0000000000001B85 45DC2800_00 -FFDFFFFFFFFFFFFF DA000000_01 -000008000007FFFE 55000000_01 -12DB4409E5AE87E6 5D96DA20_01 -FFBFFFFFFFFFFFFF DA800000_01 -FFFFFFFFFFF7BFEE C9040120_00 -FFFFFFFFFFFFFFFD C0400000_00 -FF7FFFFFFFFFFFFF DB000000_01 -000000001040FFFE 4D8207FF_01 -00000909A09C13D3 55109A09_01 -FEFFFFFFFFFFFFFF DB800000_01 -FFFFFF01FFFFFF7F D37E0000_01 -FFFFFF72E7D2575D D30D182D_01 -FDFFFFFFFFFFFFFF DC000000_01 -FFFFFFFFFFFEFFDB C7801280_00 -0000000000000017 41B80000_00 -FBFFFFFFFFFFFFFF DC800000_01 -100000001FFFFFF6 5D800000_01 -000000114B12EF51 518A5897_01 -F7FFFFFFFFFFFFFF DD000000_01 -0407FFFFFFFFFEFF 5C80FFFF_01 -FFFFFF769F3A5C2C D30960C5_01 -EFFFFFFFFFFFFFFF DD800000_01 -FFFFFFFDF7FFFFFD D0020000_01 -FFFFFFFFFFFFFFF2 C1600000_00 -DFFFFFFFFFFFFFFF DE000000_01 -FFFFFFFFFE0007FF CBFFFC00_01 -000000000000001E 41F00000_00 -BFFFFFFFFFFFFFFF DE800000_01 -FFF800000009FFFF D8FFFFFF_01 -0000000000007AA4 46F54800_00 -7FFFFFFFFFFFFFFF 5EFFFFFF_01 -4080000000FFFFFF 5E810000_01 -000000000DE7601D 4D5E7601_01 -3FFFFFFFFFFFFFFF 5E7FFFFF_01 -FFCFFFFFFFBFFFFE DA400000_01 -FFFFFFFFFFFFFFCA C2580000_00 -1FFFFFFFFFFFFFFF 5DFFFFFF_01 -000080400000003F 57004000_01 -00000000001F75A5 49FBAD28_00 -0FFFFFFFFFFFFFFF 5D7FFFFF_01 -FFFFFFEFFFFFCFFE D1800001_01 -FFFFFEE775887420 D38C453B_01 -07FFFFFFFFFFFFFF 5CFFFFFF_01 -00000000000801FE 49001FE0_00 -0000000000213FF1 4A04FFC4_00 -03FFFFFFFFFFFFFF 5C7FFFFF_01 -07FEFFFFFFFFFFEE 5CFFDFFF_01 -0000000000000004 40800000_00 -01FFFFFFFFFFFFFF 5BFFFFFF_01 -0000000820000003 51020000_01 -FFFFFFF9AD105214 D0CA5DF5_01 -00FFFFFFFFFFFFFF 5B7FFFFF_01 -FFFFF00FFFFFFFBE D57F0000_01 -FFFFFFFFFFCC48E7 CA4EDC64_00 -007FFFFFFFFFFFFF 5AFFFFFF_01 -00000FFFEF7FFFFF 557FFEF7_01 -FFFFFFFFFF0BA6CB CB745935_00 -003FFFFFFFFFFFFF 5A7FFFFF_01 -FFFFFF7FBFFFFFBF D3004000_01 -FFFFFFFFFFF24425 C95BBDB0_00 -001FFFFFFFFFFFFF 59FFFFFF_01 -200000001FFBFFFF 5E000000_01 -FFFFFF4E7115EC53 D3318EEA_01 -000FFFFFFFFFFFFF 597FFFFF_01 -FFFFF803FFFFFFBF D4FF8000_01 -FFFFFC2E539ADCFE D4746B19_01 -0007FFFFFFFFFFFF 58FFFFFF_01 -FFFFFFFFFBFFFFFF CC800000_01 -00000055084732F3 52AA108E_01 -0003FFFFFFFFFFFF 587FFFFF_01 -BFFF7FFFFFFFFE00 DE800100_01 -FFFFFFFFFFFF8543 C6F57A00_00 -0001FFFFFFFFFFFF 57FFFFFF_01 -0000001FFBFFE000 51FFDFFF_00 -FFFFFFFFFFFE491B C7DB7280_00 -0000FFFFFFFFFFFF 577FFFFF_01 -FC00200000001FFE DC7FF7FF_01 -FFFFF16898822A24 D5697677_01 -00007FFFFFFFFFFF 56FFFFFF_01 -3FFF03FFFFFFFFFE 5E7FFC0F_01 -FFFFFF8FFE18C7BF D2E003CE_01 -00003FFFFFFFFFFF 567FFFFF_01 -FFFFFEFFFEFFFFFD D3800080_01 -00F03620C1266ED9 5B703620_01 -00001FFFFFFFFFFF 55FFFFFF_01 -BF7EFFFFFFFFFFFF DE810200_01 -FFFFFFFFFFFFFFD5 C22C0000_00 -00000FFFFFFFFFFF 557FFFFF_01 -FFFBFFFFF803FFFE D8800000_01 -0000000000068684 48D0D080_00 -000007FFFFFFFFFF 54FFFFFF_01 -DFFFFFE00000001E DE000000_01 -FFFFFFFFFFFFECF5 C5985800_00 -000003FFFFFFFFFF 547FFFFF_01 -FFFF00400000FFFF D77FBFFF_01 -0000000000000002 40000000_00 -000001FFFFFFFFFF 53FFFFFF_01 -FBFFFFFFFFFFBDFE DC800000_01 -0000000000000BC9 453C9000_00 -000000FFFFFFFFFF 537FFFFF_01 -807FFFFFFFFFDFFE DEFF0000_01 -FFC274E35A70CD76 DA762C72_01 -0000007FFFFFFFFF 52FFFFFF_01 -0FFFFFFFFEFFFFFD 5D7FFFFF_01 -FFFFFFFF00E73AFC CF7F18C5_01 -0000003FFFFFFFFF 527FFFFF_01 -FFC000000001000E DA7FFFFF_01 -FFFFFFFFFFFE15E9 C7F50B80_00 -0000001FFFFFFFFF 51FFFFFF_01 -0001FFFFFFFFF3FD 57FFFFFF_01 -0000000000000033 424C0000_00 -0000000FFFFFFFFF 517FFFFF_01 -000000001FFFBFFF 4DFFFDFF_01 -FFFFFFEE6B141E1B D18CA75F_01 -00000007FFFFFFFF 50FFFFFF_01 -FFFFFFFFF60007FF CD1FFF80_01 -00000001AB310BA6 4FD59885_01 -00000003FFFFFFFF 507FFFFF_01 -0003FFFFB7FFFFFF 587FFFED_01 -FFFFFFFFFFFFF195 C566B000_00 -00000001FFFFFFFF 4FFFFFFF_01 -FFFFFFFF8000000B CEFFFFFF_01 -00000019BA8D5559 51CDD46A_01 -00000000FFFFFFFF 4F7FFFFF_01 -FBFEFFFFFFFFFFF9 DC802000_01 -FFFFFFB6F062822D D2921F3A_01 -000000007FFFFFFF 4EFFFFFF_01 -0001000000000082 57800000_01 -01CEAD9E2FB104A4 5BE756CF_01 -000000003FFFFFFF 4E7FFFFF_01 -000003FFFFFFFF7C 547FFFFF_01 -FFFFFFFFFD681E78 CC25F862_00 -000000001FFFFFFF 4DFFFFFF_01 -00002000400001FF 56000100_01 -0000000000000018 41C00000_00 -000000000FFFFFFF 4D7FFFFF_01 -3FFF80000000003E 5E7FFE00_01 -FFFFFFFFFFFFFF95 C2D60000_00 -0000000007FFFFFF 4CFFFFFF_01 -010000BFFFFFFFFF 5B80005F_01 -0000001697087B19 51B4B843_01 -0000000003FFFFFF 4C7FFFFF_01 -FBFFFFFFFFEEFFFD DC800000_01 -0000000E64BDFC55 51664BDF_01 -0000000001FFFFFF 4BFFFFFF_01 -FC00000001FFFFFE DC7FFFFF_01 -FFFED156A62AB849 D79754AC_01 -0000000000FFFFFF 4B7FFFFF_00 -FFFFFFF83FEFFFFD D0F80200_01 -00015354EAE7C259 57A9AA75_01 -00000000007FFFFF 4AFFFFFE_00 -FFFFFFFFFFFFFF7F C3010000_00 -FFFFFFF0F4DF3C75 D170B20C_01 -00000000003FFFFF 4A7FFFFC_00 -FFFA000000001FFF D8BFFFFF_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000001FFFFF 49FFFFF8_00 -FFFFFFFFFF7FFE40 CB0001C0_00 -FFFFFFDB5433CB9B D212AF30_01 -00000000000FFFFF 497FFFF0_00 -FFFFFDFFDFFDFFFD D4000800_01 -FFFFFFFFFFDEAE1F CA054784_00 -000000000007FFFF 48FFFFE0_00 -FFFFFFFFF0080006 CD7F7FFF_01 -FFFFFFFE7735DEC7 CFC46510_01 -000000000003FFFF 487FFFC0_00 -00000001FBFFFFFF 4FFDFFFF_01 -000003757D8B12ED 545D5F62_01 -000000000001FFFF 47FFFF80_00 -FFFFFE07F7FFFFFF D3FC0400_01 -00000A654064E046 55265406_01 -000000000000FFFF 477FFF00_00 -08000000000017FF 5D000000_01 -FFFFFFFFFFFFFFE7 C1C80000_00 -0000000000007FFF 46FFFE00_00 -07FFFFFFFFFFFDF6 5CFFFFFF_01 -FFFFAD78B3D6C3B6 D6A50E98_01 -0000000000003FFF 467FFC00_00 -0000300004000000 56400010_00 -FFFFFFF70B77F34F D10F4880_01 -0000000000001FFF 45FFF800_00 -FFFFFF80006FFFFE D2FFFF20_01 -0000013EB4D67EC8 539F5A6B_01 -0000000000000FFF 457FF000_00 -BFFFDFFFFBFFFFFF DE800040_01 -0005CEAF34EA1DC7 58B9D5E6_01 -00000000000007FF 44FFE000_00 -00004800007FFFFD 56900000_01 -FFFFFFFFFFFFFFFB C0A00000_00 -00000000000003FF 447FC000_00 -0000000200001000 50000004_00 -00000000000360D0 48583400_00 -00000000000001FF 43FF8000_00 -01003FFFFFFFFFFC 5B801FFF_01 -00C000708FF1BA51 5B400070_01 -00000000000000FF 437F0000_00 -F802000003FFFFFF DCFFBFFF_01 -0F9E07DCC0BDC061 5D79E07D_01 -000000000000007F 42FE0000_00 -03FF0000000000FF 5C7FC000_01 -FFFFFFE1B9B2A079 D1F2326A_01 -000000000000003F 427C0000_00 -FFF80000000080FF D8FFFFFF_01 -00000000001EB5B4 49F5ADA0_00 -000000000000001F 41F80000_00 -000000000077FBFE 4AEFF7FC_00 -00000000005AC607 4AB58C0E_00 -000000000000000F 41700000_00 -FFFFFFFEF80000FF CF83FFFF_01 -000005C5B9D66984 54B8B73A_01 -0000000000000007 40E00000_00 -C001FFFFFFF00000 DE7FF800_01 -00001D06B372AA06 55E8359B_01 -0000000000000003 40400000_00 +07FFFDFFFFFFFF7F_5CFFFFBF_01 +0000000032CC8B7A_4E4B322D_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_CE7FFF00_01 +032C857F319EDE38_5C4B215F_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_D4800000_01 +00394C79B6D3007B_5A6531E6_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_DC800001_01 +0000000001AE458D_4BD722C6_01 +0000000000000004_40800000_00 +00040008000007FE_58800100_01 +F9EB456140D88764_DCC29753_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_D5DFF800_01 +07DE834A248EDF36_5CFBD069_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC007_01 +FFFFFFFFFFE385E2_C9E3D0F0_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_DD7FBE00_01 +000000059EB1FD45_50B3D63F_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_C84001C0_00 +FFFFFFFFFFFEDDFE_C7910100_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000000C89FF56B_4F489FF5_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF7_01 +1B5E4F0BE0DEBFF0_5DDAF278_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_D801FF00_01 +FFFFFFFFFFF4766B_C9389950_00 +0000000000000400_44800000_00 +0000080100000FFE_55001000_01 +000000000000000C_41400000_00 +0000000000000800_45000000_00 +0048000000100000_5A900000_01 +FFE662A109109D0A_D9CCEAF7_01 +0000000000001000_45800000_00 +C000000037FFFFFE_DE7FFFFF_01 +FFFFFFFFFFFFFFE4_C1E00000_00 +0000000000002000_46000000_00 +F801000000100000_DCFFDFFF_01 +FE114B79075F70EE_DBF75A43_01 +0000000000004000_46800000_00 +100000000001003E_5D800000_01 +00000000000003AC_446B0000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000003_01 +00000044A3A3DBE5_52894747_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_D9FFFE08_01 +FFFFFFFFFFFF1A91_C7656F00_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_D503C000_01 +0000000000003309_464C2400_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF7_01 +FFFFFFFFFFFFFF58_C3280000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_D207F800_01 +0000000000002980_46260000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF07F_01 +000000000000005D_42BA0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF7F_01 +FFFC8C23DA2CEAD8_D85CF709_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_DDFFFFFF_01 +FFFFFDE3C1DEC43C_D4070F88_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_D77FFFF4_01 +000000000030FFBE_4A43FEF8_00 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_D7FFFFFC_01 +FFFFFFFFEFDEED86_CD810893_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_DD400000_01 +000000001DA3FF45_4DED1FFA_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_CF7FFEFF_01 +FFFFFFFE9B1BCB54_CFB2721A_01 +0000000008000000_4D000000_00 +00004000004001FE_56800000_01 +F27DD19DE6563714_DD5822E6_01 +0000000010000000_4D800000_00 +FFC00000004007FE_DA7FFFFF_01 +000000000001A359_47D1AC80_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C70003F_01 +FFFFFFFFFE62EC20_CBCE89F0_00 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E7FFFFF_01 +000000000000285F_46217C00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_CE80001F_01 +FFFFF836F99DBAA8_D4F920CC_01 +0000000100000000_4F800000_00 +00000020003FFEFE_520000FF_01 +0033466832042D47_5A4D19A0_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_C4EF2000_00 +00000000003829C8_4A60A720_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_557FFFFF_01 +0000000FB77C672B_517B77C6_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D0003FF_01 +0000000000001B78_45DBC000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_DB000000_01 +0000000000000071_42E20000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_559FFFFF_01 +FFFFFFFFFFFFFF86_C2F40000_00 +0000004000000000_52800000_00 +0800000000040800_5D000000_01 +FFF8A60D9E19F17E_D8EB3E4C_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +FFFFFFFFF7506DBA_CD0AF924_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_C7820480_00 +FFFFFFFFFEA42AC9_CBADEA9B_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_5583FFFF_01 +FFE7AA3F2BDACC89_D9C2AE06_01 +0000040000000000_54800000_00 +FFF8040000040000_D8FF7FFF_01 +FFFFFFFFFFFFFFFD_C0400000_00 +0000080000000000_55000000_00 +FFFF80000800001F_D6FFFFEF_01 +FFFDF681DECDADC9_D8025F88_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_D380000F_01 +FFFFFFFFFFFFCFBE_C6410800_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51101FFF_01 +FEC01FECA24DE1B0_DB9FF009_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_DD000000_01 +F858A66761669936_DCF4EB33_01 +0000800000000000_57000000_00 +FFFEFF800000003E_D7803FFF_01 +F716EA43FAC45C97_DD0E915B_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_C2680000_00 +0024D70EC7661FD8_5A135C3B_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_DE7E0000_01 +FFD956DBD0AEE817_DA1AA490_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FB_01 +FFFFFFFFFFFF4300_C73D0000_00 +0008000000000000_59000000_00 +4000000004002000_5E800000_01 +C12EDF40F41F6021_DE7B4482_01 +0010000000000000_59800000_00 +FF9000000000001D_DADFFFFF_01 +FFFFFFF83DE950F6_D0F842D5_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_DEFFFFF8_01 +FE2B59CB3A604D69_DBEA531A_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5EFFFFFF_01 +000000A37C210862_53237C21_01 +0080000000000000_5B000000_00 +0002000002000002_58000000_01 +FFFFB65CD8617789_D693464F_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55DFFFFF_01 +FFFFFFFFFFFFF01D_C57E3000_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800004_01 +000000000D098D19_4D5098D1_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C7FFFFF_01 +000006B3BD2C7BEF_54D677A5_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFEFF_01 +FFFF4E5ADDDAA4A8_D731A522_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE00_01 +FFFFFFFFFFFFFF21_C35F0000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83BFFF_01 +FFFFFFFFFC648262_CC66DF67_01 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_DE7FFF80_01 +FFFFFF7353AC45D2_D30CAC53_01 +8000000000000000_DF000000_00 +FFFFFFFFFFE7EFFF_C9C08008_00 +0000000000A1202D_4B21202D_00 +C000000000000000_DE800000_00 +FFFFFFFFFFFF5F7F_C7208100_00 +000000000040CA70_4A8194E0_00 +E000000000000000_DE000000_00 +0000200201FFFFFE_56000807_01 +00000003B55D87D4_506D5761_01 +F000000000000000_DD800000_00 +FF80000DFFFFFFFF_DAFFFFE4_01 +000000010510FAEF_4F82887D_01 +F800000000000000_DD000000_00 +0003FFF00000000F_587FFC00_01 +000000000000724A_46E49400_00 +FC00000000000000_DC800000_00 +FFFFFFDF80000002_D201FFFF_01 +0000000000000064_42C80000_00 +FE00000000000000_DC000000_00 +FEFFFFFFFFF800FE_DB800000_01 +FFFFFFC2C6222702_D274E777_01 +FF00000000000000_DB800000_00 +0000000408000002_50810000_01 +000000E96DF1CB41_53696DF1_01 +FF80000000000000_DB000000_00 +007FFFFFFFFFF9FE_5AFFFFFF_01 +F727F174DEE7DC85_DD0D80E8_01 +FFC0000000000000_DA800000_00 +8000000003FFFEFE_DEFFFFFF_01 +FFFFFFFFFFF0BD5B_C9742A50_00 +FFE0000000000000_DA000000_00 +0BEFFFFFFFFFFFFF_5D3EFFFF_01 +000000000002790C_481E4300_00 +FFF0000000000000_D9800000_00 +FFFFFFFFFFEFFBFA_C9802030_00 +000000169E75DF01_51B4F3AE_01 +FFF8000000000000_D9000000_00 +00000007FEFFDFFF_50FFDFFB_01 +000000000000000E_41600000_00 +FFFC000000000000_D8800000_00 +0003FFFE0007FFFE_587FFF80_01 +FFFFFFFFFFF28622_C9579DE0_00 +FFFE000000000000_D8000000_00 +FFFFFF7FFFFDF7FF_D3000002_01 +00072F0EC496FE21_58E5E1D8_01 +FFFF000000000000_D7800000_00 +DFBFFFFFFFFFFFFE_DE010000_01 +0000000000FC1FCA_4B7C1FCA_00 +FFFF800000000000_D7000000_00 +00000FFF800FFFFE_557FF800_01 +FFFF5194E4A9C2CE_D72E6B1B_01 +FFFFC00000000000_D6800000_00 +00000002100007FD_50040001_01 +FFFFFFFFFFC2D8FE_CA749C08_00 +FFFFE00000000000_D6000000_00 +000000000007FF6E_48FFEDC0_00 +000000000001766E_47BB3700_00 +FFFFF00000000000_D5800000_00 +0040000400000002_5A800008_01 +0000000000007841_46F08200_00 +FFFFF80000000000_D5000000_00 +3DFFFFFFFFFFFF7E_5E77FFFF_01 +FFFFFFE549E17E30_D1D5B0F4_01 +FFFFFC0000000000_D4800000_00 +FFFFFFFFFFFFFEE1_C38F8000_00 +FFFFFFFFFFFFFFE7_C1C80000_00 +FFFFFE0000000000_D4000000_00 +000000000EFFFFDF_4D6FFFFD_01 +FFFFFFFFFFFFFF73_C30D0000_00 +FFFFFF0000000000_D3800000_00 +FD00000008000000_DC3FFFFF_01 +000000000001DBB1_47EDD880_00 +FFFFFF8000000000_D3000000_00 +FFFFFFFFFFF8007F_C8FFF020_00 +FFFFFFFEFD10A515_CF8177AD_01 +FFFFFFC000000000_D2800000_00 +FFEFFFFFFFFFFFFE_D9800000_01 +FAB02984F6283B6C_DCA9FACF_01 +FFFFFFE000000000_D2000000_00 +FFFFFFBC000001FE_D287FFFF_01 +FEB087C6B9FE7FE0_DBA7BC1C_01 +FFFFFFF000000000_D1800000_00 +FFF80001000007FE_D8FFFFDF_01 +00F2762EA6837956_5B72762E_01 +FFFFFFF800000000_D1000000_00 +FFF7E0FFFFFFFFFE_D901F000_01 +00002E1175484626_563845D5_01 +FFFFFFFC00000000_D0800000_00 +0000200020000FFE_56000080_01 +000000000000068F_44D1E000_00 +FFFFFFFE00000000_D0000000_00 +021FFFFFFFFBFFFF_5C07FFFF_01 +FFFFFFFFFFFFFFF9_C0E00000_00 +FFFFFFFF00000000_CF800000_00 +FFFFFFD0000FFFFD_D23FFFC0_01 +000000BDF6658B83_533DF665_01 +FFFFFFFF80000000_CF000000_00 +1000001FFDFFFFFF_5D800000_01 +0000000000003B5B_466D6C00_00 +FFFFFFFFC0000000_CE800000_00 +FFFFFFBFFE0FFFFF_D28003E0_01 +FFFFFFFFFFFFFFF0_C1800000_00 +FFFFFFFFE0000000_CE000000_00 +FFFFFFFBF00007FF_D081FFFF_01 +01E986274F48EAAD_5BF4C313_01 +FFFFFFFFF0000000_CD800000_00 +1FFFFFFDFFFFFF7F_5DFFFFFF_01 +FFFFFFFFFFFFCB5A_C6529800_00 +FFFFFFFFF8000000_CD000000_00 +7FF000000000FFFF_5EFFE000_01 +00000003C2717FC3_50709C5F_01 +FFFFFFFFFC000000_CC800000_00 +FFFFFFE00008001F_D1FFFFBF_01 +FFFFFFFFFFEFABDA_C982A130_00 +FFFFFFFFFE000000_CC000000_00 +0200000000000002_5C000000_01 +FFFFFFFFF8FDA53F_CCE04B58_01 +FFFFFFFFFF000000_CB800000_00 +F6000003FFFFFFFE_DD1FFFFF_01 +FFFFFFFFFFFFFFD0_C2400000_00 +FFFFFFFFFF800000_CB000000_00 +FFFFFFFFFFBFFF7E_CA800104_00 +00000000EE0FEA62_4F6E0FEA_01 +FFFFFFFFFFC00000_CA800000_00 +0000007FFF9FFFFD_52FFFF3F_01 +00000037F35EDC1D_525FCD7B_01 +FFFFFFFFFFE00000_CA000000_00 +FFFFFFF7FDFFFF7D_D1002000_01 +00000000000001AD_43D68000_00 +FFFFFFFFFFF00000_C9800000_00 +FFFFFF0000100020_D37FFFEF_01 +27F167FBC7FC5F9A_5E1FC59F_01 +FFFFFFFFFFF80000_C9000000_00 +003FFFFFFFFC0001_5A7FFFFF_01 +000E48F9F4EBD30E_59648F9F_01 +FFFFFFFFFFFC0000_C8800000_00 +DFFFFFFFFFFBFFFE_DE000000_01 +FC91C23EE8C9424F_DC5B8F70_01 +FFFFFFFFFFFE0000_C8000000_00 +F7DFFBFFFFFFFFFE_DD020040_01 +000000002CAE080C_4E32B820_01 +FFFFFFFFFFFF0000_C7800000_00 +FFFFC00010000020_D67FFFBF_01 +04D921F917B20E40_5C9B243F_01 +FFFFFFFFFFFF8000_C7000000_00 +F8000FFFFFFFFFFD_DCFFFE00_01 +FFF17C566BC7D811_D9683A99_01 +FFFFFFFFFFFFC000_C6800000_00 +00000000000000FE_437E0000_00 +FFF82AC14930D386_D8FAA7D6_01 +FFFFFFFFFFFFE000_C6000000_00 +00000000000003FC_447F0000_00 +000E62EC60E119FC_59662EC6_01 +FFFFFFFFFFFFF000_C5800000_00 +FFFFEFF7FF7FFFFE_D5804004_01 +0E2B1ECF210EEDC5_5D62B1EC_01 +FFFFFFFFFFFFF800_C5000000_00 +00000000007FFF1F_4AFFFE3E_00 +FFFFFE534F5676F7_D3D65854_01 +FFFFFFFFFFFFFC00_C4800000_00 +0000001004FFFFFD_518027FF_01 +0000035C939669F1_545724E5_01 +FFFFFFFFFFFFFE00_C4000000_00 +1FFFFFFFFFFFFDFD_5DFFFFFF_01 +FFFFFFFFFFFFFF91_C2DE0000_00 +FFFFFFFFFFFFFF00_C3800000_00 +01FFFFFFFBFFEFFE_5BFFFFFF_01 +000000000000016E_43B70000_00 +FFFFFFFFFFFFFF80_C3000000_00 +FFF7FFFFFFFFF7FD_D9000000_01 +FFFFF8E2BCFAC553_D4E3A860_01 +FFFFFFFFFFFFFFC0_C2800000_00 +FFFFFBFFFFFE0FFE_D4800000_01 +00000001A4E704BF_4FD27382_01 +FFFFFFFFFFFFFFE0_C2000000_00 +1400007FFFFFFFFD_5DA00003_01 +FFFFFFFC93B187B4_D05B139E_01 +FFFFFFFFFFFFFFF0_C1800000_00 +40000000007FFFFD_5E800000_01 +000000000067D468_4ACFA8D0_00 +FFFFFFFFFFFFFFF8_C1000000_00 +007FFEFFFFFBFFFE_5AFFFDFF_01 +FFFFFFE26CEC79F8_D1EC989C_01 +FFFFFFFFFFFFFFFC_C0800000_00 +00FFFFFF000000FF_5B7FFFFF_01 +FFFFFFFFE0D3983A_CDF9633E_01 +FFFFFFFFFFFFFFFE_C0000000_00 +00007FFFBFFF7FFE_56FFFF7F_01 +FFFFFFFDF4A7088A_D002D63D_01 +FFFFFFFFFFFFFFFF_BF800000_00 +000008000000027E_55000000_01 +000000000000F4E8_4774E800_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFF83FFDF_CAF80042_00 +00000E11407887B2_55611407_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +04000003FFFFFFF6_5C800000_01 +0000000000000513_44A26000_00 +FFFFFFFFFFFFFFF7_C1100000_00 +BFFC00000000003E_DE8007FF_01 +00000008D7BBB75B_510D7BBB_01 +FFFFFFFFFFFFFFEF_C1880000_00 +000FFFFBFFFC0000_597FFFBF_01 +FFFFFFFFFFCD5A23_CA4A9774_00 +FFFFFFFFFFFFFFDF_C2040000_00 +FFBFDFFFBFFFFFFF_DA804000_01 +000000000000007F_42FE0000_00 +FFFFFFFFFFFFFFBF_C2820000_00 +00000007FF800003_50FFF000_01 +000000000002BB02_482EC080_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEE7FF_C78C0080_00 +00264B2B9BAD0DA2_5A192CAE_01 +FFFFFFFFFFFFFEFF_C3808000_00 +0000000000100803_49804018_00 +FF9B1DCB9F857D5E_DAC9C468_01 +FFFFFFFFFFFFFDFF_C4004000_00 +FFFFFFBFFFFFEFEE_D2800000_01 +F6FD7542899C1C6F_DD1028AB_01 +FFFFFFFFFFFFFBFF_C4802000_00 +FF800000004001FF_DAFFFFFF_01 +0000000002BE4932_4C2F924C_01 +FFFFFFFFFFFFF7FF_C5001000_00 +00001004000FFFFE_55802000_01 +FFFFFF9DAA0123E0_D2C4ABFD_01 +FFFFFFFFFFFFEFFF_C5800800_00 +00000001FDFFFDFE_4FFEFFFE_01 +FFFC1C8703B1DCB0_D878DE3F_01 +FFFFFFFFFFFFDFFF_C6000400_00 +FE0FE00000000000_DBF81000_00 +0779ED944A4E2779_5CEF3DB2_01 +FFFFFFFFFFFFBFFF_C6800200_00 +FBFFFE0400000000_DC80003F_01 +0000010127E03666_538093F0_01 +FFFFFFFFFFFF7FFF_C7000100_00 +FFFFF0200000FFFE_D57DFFFF_01 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFFFFFFEFFFF_C7800080_00 +FFEFFE0000080000_D9800FFF_01 +FFFFFFFFFD3354EA_CC332AC5_01 +FFFFFFFFFFFDFFFF_C8000040_00 +003FF0000003FFFE_5A7FC000_01 +0000006375B23F7B_52C6EB64_01 +FFFFFFFFFFFBFFFF_C8800020_00 +000407FFFFFFFFF6_5880FFFF_01 +0000000092117F38_4F12117F_01 +FFFFFFFFFFF7FFFF_C9000010_00 +FFFFFFFFFFFF7FFF_C7000100_00 +00000000000008BE_450BE000_00 +FFFFFFFFFFEFFFFF_C9800008_00 +004000020FFFFFFF_5A800004_01 +FFFFB84C2D8BC9CB_D68F67A4_01 +FFFFFFFFFFDFFFFF_CA000004_00 +00FFFFFFFFFFFFFD_5B7FFFFF_01 +00000023C2C6F284_520F0B1B_01 +FFFFFFFFFFBFFFFF_CA800002_00 +FFFDDFFFFFFFFFFD_D8080000_01 +00000000746356C4_4EE8C6AD_01 +FFFFFFFFFF7FFFFF_CB000001_00 +010000000000BFFF_5B800000_01 +FFFFFFFFFFFFFFFD_C0400000_00 +FFFFFFFFFEFFFFFF_CB800000_01 +FFFFBF7FFBFFFFFE_D6810008_01 +00000006386CE889_50C70D9D_01 +FFFFFFFFFDFFFFFF_CC000000_01 +F00000F7FFFFFFFF_DD7FFFF0_01 +FFFDFC53090C46A4_D800EB3D_01 +FFFFFFFFFBFFFFFF_CC800000_01 +0000000000800047_4B000047_00 +FFFFFFFFD693872E_CE25B1E3_01 +FFFFFFFFF7FFFFFF_CD000000_01 +000000007FBFFBFF_4EFF7FF7_01 +00000026A7845E35_521A9E11_01 +FFFFFFFFEFFFFFFF_CD800000_01 +FFFFFFDFFFFFFBFD_D2000000_01 +000000001433D14C_4DA19E8A_01 +FFFFFFFFDFFFFFFF_CE000000_01 +0001FFFFFFE0000E_57FFFFFF_01 +F0F23E8068D3D84A_DD70DC17_01 +FFFFFFFFBFFFFFFF_CE800000_01 +F7FFBFFFFFFFBFFF_DD000400_01 +FFFFBD29B7459087_D685AC91_01 +FFFFFFFF7FFFFFFF_CF000000_01 +FFFFFFF8FFFFBFFF_D0E00008_01 +FFFFFFFFFFEDDC06_C9911FD0_00 +FFFFFFFEFFFFFFFF_CF800000_01 +FFFFFFF80001FFFF_D0FFFFC0_01 +0000000000002FF9_463FE400_00 +FFFFFFFDFFFFFFFF_D0000000_01 +004000040000FFFF_5A800008_01 +FFFFFFFFFFFFFFF1_C1700000_00 +FFFFFFFBFFFFFFFF_D0800000_01 +C0000000007FFFFA_DE7FFFFF_01 +FFFFFFFFFE053E2B_CBFD60EA_01 +FFFFFFF7FFFFFFFF_D1000000_01 +7FFE000007FFFFFF_5EFFFC00_01 +000000000000000D_41500000_00 +FFFFFFEFFFFFFFFF_D1800000_01 +F80000000001007E_DCFFFFFF_01 +FFFFED48424AD9D6_D595BDED_01 +FFFFFFDFFFFFFFFF_D2000000_01 +FFFFFE0001FEFFFF_D3FFFF00_01 +000000000000013B_439D8000_00 +FFFFFFBFFFFFFFFF_D2800000_01 +0007FBFFFFFDFFFE_58FF7FFF_01 +4A16BD4128090C83_5E942D7A_01 +FFFFFF7FFFFFFFFF_D3000000_01 +00FFF7FFFF7FFFFE_5B7FF7FF_01 +0000000000000006_40C00000_00 +FFFFFEFFFFFFFFFF_D3800000_01 +FBFFFFBFFFBFFFFF_DC800008_01 +00000000000001BA_43DD0000_00 +FFFFFDFFFFFFFFFF_D4000000_01 +0000000040000082_4E800001_01 +FF07A2BF5B689F89_DB785D40_01 +FFFFFBFFFFFFFFFF_D4800000_01 +0000001FF8000008_51FFC000_01 +F87CAA7DE672DE8B_DCF06AB0_01 +FFFFF7FFFFFFFFFF_D5000000_01 +07FFF80000000002_5CFFFF00_01 +0000000010A1E5B8_4D850F2D_01 +FFFFEFFFFFFFFFFF_D5800000_01 +F7FFFFE00007FFFF_DD000001_01 +FFFFFFFFFFF6ADFC_C9152040_00 +FFFFDFFFFFFFFFFF_D6000000_01 +FFFFFF03FFFFFFC0_D37C0000_01 +EA579475948F0032_DDAD435C_01 +FFFFBFFFFFFFFFFF_D6800000_01 +FC00000000003FF6_DC7FFFFF_01 +002E677AC313BF60_5A399DEB_01 +FFFF7FFFFFFFFFFF_D7000000_01 +02000007FF7FFFFF_5C000001_01 +0000000E999639F1_51699963_01 +FFFEFFFFFFFFFFFF_D7800000_01 +FFFF83FFFFFFFFBE_D6F80000_01 +000000000001537D_47A9BE80_00 +FFFDFFFFFFFFFFFF_D8000000_01 +EFFFFFC00000003D_DD800001_01 +FFFFFFF21FEDFD35_D15E0120_01 +FFFBFFFFFFFFFFFF_D8800000_01 +FFFFFFF0000007FE_D17FFFFF_01 +FFFFFFFFFFDE0839_CA07DF1C_00 +FFF7FFFFFFFFFFFF_D9000000_01 +0000007FFFE000FF_52FFFFC0_01 +FFFFFFFF79F30F48_CF060CF0_01 +FFEFFFFFFFFFFFFF_D9800000_01 +FFFFFC13FFFFFFFD_D47B0000_01 +0000000000001B85_45DC2800_00 +FFDFFFFFFFFFFFFF_DA000000_01 +000008000007FFFE_55000000_01 +12DB4409E5AE87E6_5D96DA20_01 +FFBFFFFFFFFFFFFF_DA800000_01 +FFFFFFFFFFF7BFEE_C9040120_00 +FFFFFFFFFFFFFFFD_C0400000_00 +FF7FFFFFFFFFFFFF_DB000000_01 +000000001040FFFE_4D8207FF_01 +00000909A09C13D3_55109A09_01 +FEFFFFFFFFFFFFFF_DB800000_01 +FFFFFF01FFFFFF7F_D37E0000_01 +FFFFFF72E7D2575D_D30D182D_01 +FDFFFFFFFFFFFFFF_DC000000_01 +FFFFFFFFFFFEFFDB_C7801280_00 +0000000000000017_41B80000_00 +FBFFFFFFFFFFFFFF_DC800000_01 +100000001FFFFFF6_5D800000_01 +000000114B12EF51_518A5897_01 +F7FFFFFFFFFFFFFF_DD000000_01 +0407FFFFFFFFFEFF_5C80FFFF_01 +FFFFFF769F3A5C2C_D30960C5_01 +EFFFFFFFFFFFFFFF_DD800000_01 +FFFFFFFDF7FFFFFD_D0020000_01 +FFFFFFFFFFFFFFF2_C1600000_00 +DFFFFFFFFFFFFFFF_DE000000_01 +FFFFFFFFFE0007FF_CBFFFC00_01 +000000000000001E_41F00000_00 +BFFFFFFFFFFFFFFF_DE800000_01 +FFF800000009FFFF_D8FFFFFF_01 +0000000000007AA4_46F54800_00 +7FFFFFFFFFFFFFFF_5EFFFFFF_01 +4080000000FFFFFF_5E810000_01 +000000000DE7601D_4D5E7601_01 +3FFFFFFFFFFFFFFF_5E7FFFFF_01 +FFCFFFFFFFBFFFFE_DA400000_01 +FFFFFFFFFFFFFFCA_C2580000_00 +1FFFFFFFFFFFFFFF_5DFFFFFF_01 +000080400000003F_57004000_01 +00000000001F75A5_49FBAD28_00 +0FFFFFFFFFFFFFFF_5D7FFFFF_01 +FFFFFFEFFFFFCFFE_D1800001_01 +FFFFFEE775887420_D38C453B_01 +07FFFFFFFFFFFFFF_5CFFFFFF_01 +00000000000801FE_49001FE0_00 +0000000000213FF1_4A04FFC4_00 +03FFFFFFFFFFFFFF_5C7FFFFF_01 +07FEFFFFFFFFFFEE_5CFFDFFF_01 +0000000000000004_40800000_00 +01FFFFFFFFFFFFFF_5BFFFFFF_01 +0000000820000003_51020000_01 +FFFFFFF9AD105214_D0CA5DF5_01 +00FFFFFFFFFFFFFF_5B7FFFFF_01 +FFFFF00FFFFFFFBE_D57F0000_01 +FFFFFFFFFFCC48E7_CA4EDC64_00 +007FFFFFFFFFFFFF_5AFFFFFF_01 +00000FFFEF7FFFFF_557FFEF7_01 +FFFFFFFFFF0BA6CB_CB745935_00 +003FFFFFFFFFFFFF_5A7FFFFF_01 +FFFFFF7FBFFFFFBF_D3004000_01 +FFFFFFFFFFF24425_C95BBDB0_00 +001FFFFFFFFFFFFF_59FFFFFF_01 +200000001FFBFFFF_5E000000_01 +FFFFFF4E7115EC53_D3318EEA_01 +000FFFFFFFFFFFFF_597FFFFF_01 +FFFFF803FFFFFFBF_D4FF8000_01 +FFFFFC2E539ADCFE_D4746B19_01 +0007FFFFFFFFFFFF_58FFFFFF_01 +FFFFFFFFFBFFFFFF_CC800000_01 +00000055084732F3_52AA108E_01 +0003FFFFFFFFFFFF_587FFFFF_01 +BFFF7FFFFFFFFE00_DE800100_01 +FFFFFFFFFFFF8543_C6F57A00_00 +0001FFFFFFFFFFFF_57FFFFFF_01 +0000001FFBFFE000_51FFDFFF_00 +FFFFFFFFFFFE491B_C7DB7280_00 +0000FFFFFFFFFFFF_577FFFFF_01 +FC00200000001FFE_DC7FF7FF_01 +FFFFF16898822A24_D5697677_01 +00007FFFFFFFFFFF_56FFFFFF_01 +3FFF03FFFFFFFFFE_5E7FFC0F_01 +FFFFFF8FFE18C7BF_D2E003CE_01 +00003FFFFFFFFFFF_567FFFFF_01 +FFFFFEFFFEFFFFFD_D3800080_01 +00F03620C1266ED9_5B703620_01 +00001FFFFFFFFFFF_55FFFFFF_01 +BF7EFFFFFFFFFFFF_DE810200_01 +FFFFFFFFFFFFFFD5_C22C0000_00 +00000FFFFFFFFFFF_557FFFFF_01 +FFFBFFFFF803FFFE_D8800000_01 +0000000000068684_48D0D080_00 +000007FFFFFFFFFF_54FFFFFF_01 +DFFFFFE00000001E_DE000000_01 +FFFFFFFFFFFFECF5_C5985800_00 +000003FFFFFFFFFF_547FFFFF_01 +FFFF00400000FFFF_D77FBFFF_01 +0000000000000002_40000000_00 +000001FFFFFFFFFF_53FFFFFF_01 +FBFFFFFFFFFFBDFE_DC800000_01 +0000000000000BC9_453C9000_00 +000000FFFFFFFFFF_537FFFFF_01 +807FFFFFFFFFDFFE_DEFF0000_01 +FFC274E35A70CD76_DA762C72_01 +0000007FFFFFFFFF_52FFFFFF_01 +0FFFFFFFFEFFFFFD_5D7FFFFF_01 +FFFFFFFF00E73AFC_CF7F18C5_01 +0000003FFFFFFFFF_527FFFFF_01 +FFC000000001000E_DA7FFFFF_01 +FFFFFFFFFFFE15E9_C7F50B80_00 +0000001FFFFFFFFF_51FFFFFF_01 +0001FFFFFFFFF3FD_57FFFFFF_01 +0000000000000033_424C0000_00 +0000000FFFFFFFFF_517FFFFF_01 +000000001FFFBFFF_4DFFFDFF_01 +FFFFFFEE6B141E1B_D18CA75F_01 +00000007FFFFFFFF_50FFFFFF_01 +FFFFFFFFF60007FF_CD1FFF80_01 +00000001AB310BA6_4FD59885_01 +00000003FFFFFFFF_507FFFFF_01 +0003FFFFB7FFFFFF_587FFFED_01 +FFFFFFFFFFFFF195_C566B000_00 +00000001FFFFFFFF_4FFFFFFF_01 +FFFFFFFF8000000B_CEFFFFFF_01 +00000019BA8D5559_51CDD46A_01 +00000000FFFFFFFF_4F7FFFFF_01 +FBFEFFFFFFFFFFF9_DC802000_01 +FFFFFFB6F062822D_D2921F3A_01 +000000007FFFFFFF_4EFFFFFF_01 +0001000000000082_57800000_01 +01CEAD9E2FB104A4_5BE756CF_01 +000000003FFFFFFF_4E7FFFFF_01 +000003FFFFFFFF7C_547FFFFF_01 +FFFFFFFFFD681E78_CC25F862_00 +000000001FFFFFFF_4DFFFFFF_01 +00002000400001FF_56000100_01 +0000000000000018_41C00000_00 +000000000FFFFFFF_4D7FFFFF_01 +3FFF80000000003E_5E7FFE00_01 +FFFFFFFFFFFFFF95_C2D60000_00 +0000000007FFFFFF_4CFFFFFF_01 +010000BFFFFFFFFF_5B80005F_01 +0000001697087B19_51B4B843_01 +0000000003FFFFFF_4C7FFFFF_01 +FBFFFFFFFFEEFFFD_DC800000_01 +0000000E64BDFC55_51664BDF_01 +0000000001FFFFFF_4BFFFFFF_01 +FC00000001FFFFFE_DC7FFFFF_01 +FFFED156A62AB849_D79754AC_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_D0F80200_01 +00015354EAE7C259_57A9AA75_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_C3010000_00 +FFFFFFF0F4DF3C75_D170B20C_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_D8BFFFFF_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_CB0001C0_00 +FFFFFFDB5433CB9B_D212AF30_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_D4000800_01 +FFFFFFFFFFDEAE1F_CA054784_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_CD7F7FFF_01 +FFFFFFFE7735DEC7_CFC46510_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFDFFFF_01 +000003757D8B12ED_545D5F62_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_D3FC0400_01 +00000A654064E046_55265406_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000000_01 +FFFFFFFFFFFFFFE7_C1C80000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5CFFFFFF_01 +FFFFAD78B3D6C3B6_D6A50E98_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +FFFFFFF70B77F34F_D10F4880_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_D2FFFF20_01 +0000013EB4D67EC8_539F5A6B_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_DE800040_01 +0005CEAF34EA1DC7_58B9D5E6_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900000_01 +FFFFFFFFFFFFFFFB_C0A00000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000360D0_48583400_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B801FFF_01 +00C000708FF1BA51_5B400070_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_DCFFBFFF_01 +0F9E07DCC0BDC061_5D79E07D_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC000_01 +FFFFFFE1B9B2A079_D1F2326A_01 +000000000000003F_427C0000_00 +FFF80000000080FF_D8FFFFFF_01 +00000000001EB5B4_49F5ADA0_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +00000000005AC607_4AB58C0E_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_CF83FFFF_01 +000005C5B9D66984_54B8B73A_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_DE7FF800_01 +00001D06B372AA06_55E8359B_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_rd.tv b/wally-pipelined/testbench/fp/i64_f64_rd.tv index eaab9a1ee..771d36c2c 100644 --- a/wally-pipelined/testbench/fp/i64_f64_rd.tv +++ b/wally-pipelined/testbench/fp/i64_f64_rd.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 439FFFF7FFFFFFFD_01 -0000000032CC8B7A 41C96645BD000000_00 -0000000000000000 0000000000000000_00 -FFFFFFFFC0003FFE C1CFFFE001000000_00 -032C857F319EDE38 4389642BF98CF6F1_01 -0000000000000001 3FF0000000000000_00 -FFFFFBFFFFF8003E C29000001FFF0800_00 -00394C79B6D3007B 434CA63CDB69803D_01 -0000000000000002 4000000000000000_00 -FBFFFFF0000001FF C39000003FFFFFF9_01 -0000000001AE458D 417AE458D0000000_00 -0000000000000004 4010000000000000_00 -00040008000007FE 4310002000001FF8_00 -F9EB456140D88764 C39852EA7AFC9DE3_01 -0000000000000008 4020000000000000_00 -FFFFE400FFFFFFFE C2BBFF0000000200_00 -07DE834A248EDF36 439F7A0D28923B7C_01 -0000000000000010 4030000000000000_00 -00000003FF001FFF 420FF800FFF80000_00 -FFFFFFFFFFE385E2 C13C7A1E00000000_00 -0000000000000020 4040000000000000_00 -F0041FFFFFFFFFFF C3AFF7C000000001_01 -000000059EB1FD45 42167AC7F5140000_00 -0000000000000040 4050000000000000_00 -FFFFFFFFFFFCFFF9 C108003800000000_00 -FFFFFFFFFFFEDDFE C0F2202000000000_00 -0000000000000080 4060000000000000_00 -000000000003FF00 410FF80000000000_00 -00000000C89FF56B 41E913FEAD600000_00 -0000000000000100 4070000000000000_00 -000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 -1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEBF_01 -0000000000000200 4080000000000000_00 -FFFDF803FFFFFFFF C3003FE000000008_00 -FFFFFFFFFFF4766B C127132A00000000_00 -0000000000000400 4090000000000000_00 -0000080100000FFE 42A00200001FFC00_00 -000000000000000C 4028000000000000_00 -0000000000000800 40A0000000000000_00 -0048000000100000 4352000000040000_00 -FFE662A109109D0A C3399D5EF6EF62F6_00 -0000000000001000 40B0000000000000_00 -C000000037FFFFFE C3CFFFFFFFE40001_01 -FFFFFFFFFFFFFFE4 C03C000000000000_00 -0000000000002000 40C0000000000000_00 -F801000000100000 C39FFBFFFFFFC000_00 -FE114B79075F70EE C37EEB486F8A08F2_01 -0000000000004000 40D0000000000000_00 -100000000001003E 43B0000000000100_01 -00000000000003AC 408D600000000000_00 -0000000000008000 40E0000000000000_00 -200000FFFFFFF800 43C000007FFFFFFC_00 -00000044A3A3DBE5 425128E8F6F94000_00 -0000000000010000 40F0000000000000_00 -FFE0003EFFFFFFFF C33FFFC100000001_00 -FFFFFFFFFFFF1A91 C0ECADE000000000_00 -0000000000020000 4100000000000000_00 -FFFFF7C3FFFFFFFD C2A0780000000600_00 -0000000000003309 40C9848000000000_00 -0000000000040000 4110000000000000_00 -000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 -FFFFFFFFFFFFFF58 C065000000000000_00 -0000000000080000 4120000000000000_00 -FFFFFFDE01FFFFFE C240FF0000010000_00 -0000000000002980 40C4C00000000000_00 -0000000000100000 4130000000000000_00 -00000000FFF07FFF 41EFFE0FFFE00000_00 -000000000000005D 4057400000000000_00 -0000000000200000 4140000000000000_00 -000020FFDFFFFFFF 42C07FEFFFFFFF80_00 -FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 -0000000000400000 4150000000000000_00 -E0000000003FFFDF C3BFFFFFFFFFC001_01 -FFFFFDE3C1DEC43C C280E1F109DE2000_00 -0000000000800000 4160000000000000_00 -FFFF00000BFFFFFD C2EFFFFE80000060_00 -000000000030FFBE 41487FDF00000000_00 -0000000001000000 4170000000000000_00 -FFFE000007FFEFFD C2FFFFFF80010030_00 -FFFFFFFFEFDEED86 C1B021127A000000_00 -0000000002000000 4180000000000000_00 -F3FFFFFFFFBFFFFE C3A8000000008001_01 -000000001DA3FF45 41BDA3FF45000000_00 -0000000004000000 4190000000000000_00 -FFFFFFFF00010007 C1EFFFDFFF200000_00 -FFFFFFFE9B1BCB54 C1F64E434AC00000_00 -0000000008000000 41A0000000000000_00 -00004000004001FE 42D0000010007F80_00 -F27DD19DE6563714 C3AB045CC4335392_01 -0000000010000000 41B0000000000000_00 -FFC00000004007FE C34FFFFFFFDFFC01_00 -000000000001A359 40FA359000000000_00 -0000000020000000 41C0000000000000_00 -0000000003C000FE 418E0007F0000000_00 -FFFFFFFFFE62EC20 C179D13E00000000_00 -0000000040000000 41D0000000000000_00 -000000003FFFFFFD 41CFFFFFFE800000_00 -000000000000285F 40C42F8000000000_00 -0000000080000000 41E0000000000000_00 -FFFFFFFFBFFFF00F C1D00003FC400000_00 -FFFFF836F99DBAA8 C29F241989156000_00 -0000000100000000 41F0000000000000_00 -00000020003FFEFE 4240001FFF7F0000_00 -0033466832042D47 4349A334190216A3_01 -0000000200000000 4200000000000000_00 -FFFFFFFFFFFFF887 C09DE40000000000_00 -00000000003829C8 414C14E400000000_00 -0000000400000000 4210000000000000_00 -00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 -0000000FB77C672B 422F6EF8CE560000_00 -0000000800000000 4220000000000000_00 -08003FFDFFFFFFFE 43A0007FFBFFFFFF_01 -0000000000001B78 40BB780000000000_00 -0000001000000000 4230000000000000_00 -FF7FFFFFFFEFDFFF C360000000020401_01 -0000000000000071 405C400000000000_00 -0000002000000000 4240000000000000_00 -000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 -FFFFFFFFFFFFFF86 C05E800000000000_00 -0000004000000000 4250000000000000_00 -0800000000040800 43A0000000000810_00 -FFF8A60D9E19F17E C31D67C987983A08_00 -0000008000000000 4260000000000000_00 -000077FFF0000000 42DDFFFC00000000_00 -FFFFFFFFF7506DBA C1A15F248C000000_00 -0000010000000000 4270000000000000_00 -FFFFFFFFFFFEFBF7 C0F0409000000000_00 -FFFFFFFFFEA42AC9 C175BD5370000000_00 -0000020000000000 4280000000000000_00 -0000107FFFFFDFFD 42B07FFFFFDFFD00_00 -FFE7AA3F2BDACC89 C33855C0D4253377_00 -0000040000000000 4290000000000000_00 -FFF8040000040000 C31FEFFFFFF00000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -0000080000000000 42A0000000000000_00 -FFFF80000800001F C2DFFFFDFFFFF840_00 -FFFDF681DECDADC9 C3004BF1099291B8_00 -0000100000000000 42B0000000000000_00 -FFFFFEFFFFE0007F C2700001FFF81000_00 -FFFFFFFFFFFFCFBE C0C8210000000000_00 -0000200000000000 42C0000000000000_00 -0000000901FFFFFD 422203FFFFFA0000_00 -FEC01FECA24DE1B0 C373FE0135DB21E5_00 -0000400000000000 42D0000000000000_00 -F7FFFFFFDFFF7FFF C3A0000000400101_01 -F858A66761669936 C39E9D66627A659C_01 -0000800000000000 42E0000000000000_00 -FFFEFF800000003E C2F007FFFFFFFC20_00 -F716EA43FAC45C97 C3A1D22B780A7747_01 -0001000000000000 42F0000000000000_00 -FFFFFFFFFFFFFFC6 C04D000000000000_00 -0024D70EC7661FD8 43426B8763B30FEC_00 -0002000000000000 4300000000000000_00 -C07FFFFFFFFFFFFE C3CFC00000000001_01 -FFD956DBD0AEE817 C343549217A88BF5_01 -0004000000000000 4310000000000000_00 -020003EFFFFFFFFE 4380001F7FFFFFFF_01 -FFFFFFFFFFFF4300 C0E7A00000000000_00 -0008000000000000 4320000000000000_00 -4000000004002000 43D0000000010008_00 -C12EDF40F41F6021 C3CF68905F85F050_01 -0010000000000000 4330000000000000_00 -FF9000000000001D C35BFFFFFFFFFFF9_01 -FFFFFFF83DE950F6 C21F085ABC280000_00 -0020000000000000 4340000000000000_00 -800003FFFFFC0000 C3DFFFFF00000100_00 -FE2B59CB3A604D69 C37D4A634C59FB2A_01 -0040000000000000 4350000000000000_00 -7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFEF_01 -000000A37C210862 42646F84210C4000_00 -0080000000000000 4360000000000000_00 -0002000002000002 4300000010000010_00 -FFFFB65CD8617789 C2D268C9E7A21DC0_00 -0100000000000000 4370000000000000_00 -00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 -FFFFFFFFFFFFF01D C0AFC60000000000_00 -0200000000000000 4380000000000000_00 -1000008000003FFF 43B000008000003F_01 -000000000D098D19 41AA131A32000000_00 -0400000000000000 4390000000000000_00 -03FFFFFFFFFFF5FF 438FFFFFFFFFFFAF_01 -000006B3BD2C7BEF 429ACEF4B1EFBC00_00 -0800000000000000 43A0000000000000_00 -00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 -FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 -1000000000000000 43B0000000000000_00 -001FFFC000000FFD 433FFFC000000FFD_00 -FFFFFFFFFFFFFF21 C06BE00000000000_00 -2000000000000000 43C0000000000000_00 -0000000041DFFFFF 41D077FFFFC00000_00 -FFFFFFFFFC648262 C18CDBECF0000000_00 -4000000000000000 43D0000000000000_00 -C0001FFFFFFFFFFB C3CFFFF000000001_01 -FFFFFF7353AC45D2 C261958A7745C000_00 -8000000000000000 C3E0000000000000_00 -FFFFFFFFFFE7EFFF C138100100000000_00 -0000000000A1202D 41642405A0000000_00 -C000000000000000 C3D0000000000000_00 -FFFFFFFFFFFF5F7F C0E4102000000000_00 -000000000040CA70 4150329C00000000_00 -E000000000000000 C3C0000000000000_00 -0000200201FFFFFE 42C00100FFFFFF00_00 -00000003B55D87D4 420DAAEC3EA00000_00 -F000000000000000 C3B0000000000000_00 -FF80000DFFFFFFFF C35FFFFC80000001_01 -000000010510FAEF 41F0510FAEF00000_00 -F800000000000000 C3A0000000000000_00 -0003FFF00000000F 430FFF8000000078_00 -000000000000724A 40DC928000000000_00 -FC00000000000000 C390000000000000_00 -FFFFFFDF80000002 C2403FFFFFFF0000_00 -0000000000000064 4059000000000000_00 -FE00000000000000 C380000000000000_00 -FEFFFFFFFFF800FE C370000000007FF1_01 -FFFFFFC2C6222702 C24E9CEEEC7F0000_00 -FF00000000000000 C370000000000000_00 -0000000408000002 4210200000080000_00 -000000E96DF1CB41 426D2DBE39682000_00 -FF80000000000000 C360000000000000_00 -007FFFFFFFFFF9FE 435FFFFFFFFFFE7F_01 -F727F174DEE7DC85 C3A1B01D16423047_01 -FFC0000000000000 C350000000000000_00 -8000000003FFFEFE C3DFFFFFFFFF0001_01 -FFFFFFFFFFF0BD5B C12E854A00000000_00 -FFE0000000000000 C340000000000000_00 -0BEFFFFFFFFFFFFF 43A7DFFFFFFFFFFF_01 -000000000002790C 4103C86000000000_00 -FFF0000000000000 C330000000000000_00 -FFFFFFFFFFEFFBFA C130040600000000_00 -000000169E75DF01 42369E75DF010000_00 -FFF8000000000000 C320000000000000_00 -00000007FEFFDFFF 421FFBFF7FFC0000_00 -000000000000000E 402C000000000000_00 -FFFC000000000000 C310000000000000_00 -0003FFFE0007FFFE 430FFFF0003FFFF0_00 -FFFFFFFFFFF28622 C12AF3BC00000000_00 -FFFE000000000000 C300000000000000_00 -FFFFFF7FFFFDF7FF C260000041002000_00 -00072F0EC496FE21 431CBC3B125BF884_00 -FFFF000000000000 C2F0000000000000_00 -DFBFFFFFFFFFFFFE C3C0200000000001_01 -0000000000FC1FCA 416F83F940000000_00 -FFFF800000000000 C2E0000000000000_00 -00000FFF800FFFFE 42AFFF001FFFFC00_00 -FFFF5194E4A9C2CE C2E5CD636AC7A640_00 -FFFFC00000000000 C2D0000000000000_00 -00000002100007FD 420080003FE80000_00 -FFFFFFFFFFC2D8FE C14E938100000000_00 -FFFFE00000000000 C2C0000000000000_00 -000000000007FF6E 411FFDB800000000_00 -000000000001766E 40F766E000000000_00 -FFFFF00000000000 C2B0000000000000_00 -0040000400000002 4350000100000000_01 -0000000000007841 40DE104000000000_00 -FFFFF80000000000 C2A0000000000000_00 -3DFFFFFFFFFFFF7E 43CEFFFFFFFFFFFF_01 -FFFFFFE549E17E30 C23AB61E81D00000_00 -FFFFFC0000000000 C290000000000000_00 -FFFFFFFFFFFFFEE1 C071F00000000000_00 -FFFFFFFFFFFFFFE7 C039000000000000_00 -FFFFFE0000000000 C280000000000000_00 -000000000EFFFFDF 41ADFFFFBE000000_00 -FFFFFFFFFFFFFF73 C061A00000000000_00 -FFFFFF0000000000 C270000000000000_00 -FD00000008000000 C387FFFFFFC00000_00 -000000000001DBB1 40FDBB1000000000_00 -FFFFFF8000000000 C260000000000000_00 -FFFFFFFFFFF8007F C11FFE0400000000_00 -FFFFFFFEFD10A515 C1F02EF5AEB00000_00 -FFFFFFC000000000 C250000000000000_00 -FFEFFFFFFFFFFFFE C330000000000002_00 -FAB02984F6283B6C C3953F59EC275F13_01 -FFFFFFE000000000 C240000000000000_00 -FFFFFFBC000001FE C250FFFFFF808000_00 -FEB087C6B9FE7FE0 C374F78394601802_00 -FFFFFFF000000000 C230000000000000_00 -FFF80001000007FE C31FFFFBFFFFE008_00 -00F2762EA6837956 436E4EC5D4D06F2A_01 -FFFFFFF800000000 C220000000000000_00 -FFF7E0FFFFFFFFFE C3203E0000000004_00 -00002E1175484626 42C708BAA4231300_00 -FFFFFFFC00000000 C210000000000000_00 -0000200020000FFE 42C000100007FF00_00 -000000000000068F 409A3C0000000000_00 -FFFFFFFE00000000 C200000000000000_00 -021FFFFFFFFBFFFF 4380FFFFFFFFDFFF_01 -FFFFFFFFFFFFFFF9 C01C000000000000_00 -FFFFFFFF00000000 C1F0000000000000_00 -FFFFFFD0000FFFFD C247FFF800018000_00 -000000BDF6658B83 4267BECCB1706000_00 -FFFFFFFF80000000 C1E0000000000000_00 -1000001FFDFFFFFF 43B000001FFDFFFF_01 -0000000000003B5B 40CDAD8000000000_00 -FFFFFFFFC0000000 C1D0000000000000_00 -FFFFFFBFFE0FFFFF C250007C00004000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -FFFFFFFFE0000000 C1C0000000000000_00 -FFFFFFFBF00007FF C2103FFFE0040000_00 -01E986274F48EAAD 437E986274F48EAA_01 -FFFFFFFFF0000000 C1B0000000000000_00 -1FFFFFFDFFFFFF7F 43BFFFFFFDFFFFFF_01 -FFFFFFFFFFFFCB5A C0CA530000000000_00 -FFFFFFFFF8000000 C1A0000000000000_00 -7FF000000000FFFF 43DFFC000000003F_01 -00000003C2717FC3 420E138BFE180000_00 -FFFFFFFFFC000000 C190000000000000_00 -FFFFFFE00008001F C23FFFF7FFE10000_00 -FFFFFFFFFFEFABDA C130542600000000_00 -FFFFFFFFFE000000 C180000000000000_00 -0200000000000002 4380000000000000_01 -FFFFFFFFF8FDA53F C19C096B04000000_00 -FFFFFFFFFF000000 C170000000000000_00 -F6000003FFFFFFFE C3A3FFFFF8000001_01 -FFFFFFFFFFFFFFD0 C048000000000000_00 -FFFFFFFFFF800000 C160000000000000_00 -FFFFFFFFFFBFFF7E C150002080000000_00 -00000000EE0FEA62 41EDC1FD4C400000_00 -FFFFFFFFFFC00000 C150000000000000_00 -0000007FFF9FFFFD 425FFFE7FFFF4000_00 -00000037F35EDC1D 424BF9AF6E0E8000_00 -FFFFFFFFFFE00000 C140000000000000_00 -FFFFFFF7FDFFFF7D C220040001060000_00 -00000000000001AD 407AD00000000000_00 -FFFFFFFFFFF00000 C130000000000000_00 -FFFFFF0000100020 C26FFFFDFFFC0000_00 -27F167FBC7FC5F9A 43C3F8B3FDE3FE2F_01 -FFFFFFFFFFF80000 C120000000000000_00 -003FFFFFFFFC0001 434FFFFFFFFE0000_01 -000E48F9F4EBD30E 432C91F3E9D7A61C_00 -FFFFFFFFFFFC0000 C110000000000000_00 -DFFFFFFFFFFBFFFE C3C0000000000201_01 -FC91C23EE8C9424F C38B71EE08B9B5EE_01 -FFFFFFFFFFFE0000 C100000000000000_00 -F7DFFBFFFFFFFFFE C3A0400800000001_01 -000000002CAE080C 41C6570406000000_00 -FFFFFFFFFFFF0000 C0F0000000000000_00 -FFFFC00010000020 C2CFFFF7FFFFF000_00 -04D921F917B20E40 43936487E45EC839_00 -FFFFFFFFFFFF8000 C0E0000000000000_00 -F8000FFFFFFFFFFD C39FFFC000000001_01 -FFF17C566BC7D811 C32D075328704FDE_00 -FFFFFFFFFFFFC000 C0D0000000000000_00 -00000000000000FE 406FC00000000000_00 -FFF82AC14930D386 C31F54FADB3CB1E8_00 -FFFFFFFFFFFFE000 C0C0000000000000_00 -00000000000003FC 408FE00000000000_00 -000E62EC60E119FC 432CC5D8C1C233F8_00 -FFFFFFFFFFFFF000 C0B0000000000000_00 -FFFFEFF7FF7FFFFE C2B0080080000200_00 -0E2B1ECF210EEDC5 43AC563D9E421DDB_01 -FFFFFFFFFFFFF800 C0A0000000000000_00 -00000000007FFF1F 415FFFC7C0000000_00 -FFFFFE534F5676F7 C27ACB0A98909000_00 -FFFFFFFFFFFFFC00 C090000000000000_00 -0000001004FFFFFD 423004FFFFFD0000_00 -0000035C939669F1 428AE49CB34F8800_00 -FFFFFFFFFFFFFE00 C080000000000000_00 -1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFD_01 -FFFFFFFFFFFFFF91 C05BC00000000000_00 -FFFFFFFFFFFFFF00 C070000000000000_00 -01FFFFFFFBFFEFFE 437FFFFFFFBFFEFF_01 -000000000000016E 4076E00000000000_00 -FFFFFFFFFFFFFF80 C060000000000000_00 -FFF7FFFFFFFFF7FD C320000000001006_00 -FFFFF8E2BCFAC553 C29C750C14EAB400_00 -FFFFFFFFFFFFFFC0 C050000000000000_00 -FFFFFBFFFFFE0FFE C290000007C00800_00 -00000001A4E704BF 41FA4E704BF00000_00 -FFFFFFFFFFFFFFE0 C040000000000000_00 -1400007FFFFFFFFD 43B400007FFFFFFF_01 -FFFFFFFC93B187B4 C20B6273C2600000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -40000000007FFFFD 43D0000000001FFF_01 -000000000067D468 4159F51A00000000_00 -FFFFFFFFFFFFFFF8 C020000000000000_00 -007FFEFFFFFBFFFE 435FFFBFFFFEFFFF_01 -FFFFFFE26CEC79F8 C23D931386080000_00 -FFFFFFFFFFFFFFFC C010000000000000_00 -00FFFFFF000000FF 436FFFFFE000001F_01 -FFFFFFFFE0D3983A C1BF2C67C6000000_00 -FFFFFFFFFFFFFFFE C000000000000000_00 -00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 -FFFFFFFDF4A7088A C2005AC7BBB00000_00 -FFFFFFFFFFFFFFFF BFF0000000000000_00 -000008000000027E 42A000000004FC00_00 -000000000000F4E8 40EE9D0000000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFF83FFDF C15F000840000000_00 -00000E11407887B2 42AC2280F10F6400_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -04000003FFFFFFF6 439000000FFFFFFF_01 -0000000000000513 40944C0000000000_00 -FFFFFFFFFFFFFFF7 C022000000000000_00 -BFFC00000000003E C3D0010000000000_01 -00000008D7BBB75B 4221AF776EB60000_00 -FFFFFFFFFFFFFFEF C031000000000000_00 -000FFFFBFFFC0000 432FFFF7FFF80000_00 -FFFFFFFFFFCD5A23 C14952EE80000000_00 -FFFFFFFFFFFFFFDF C040800000000000_00 -FFBFDFFFBFFFFFFF C350080010000001_01 -000000000000007F 405FC00000000000_00 -FFFFFFFFFFFFFFBF C050400000000000_00 -00000007FF800003 421FFE00000C0000_00 -000000000002BB02 4105D81000000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEE7FF C0F1801000000000_00 -00264B2B9BAD0DA2 43432595CDD686D1_00 -FFFFFFFFFFFFFEFF C070100000000000_00 -0000000000100803 4130080300000000_00 -FF9B1DCB9F857D5E C359388D181EA0A9_01 -FFFFFFFFFFFFFDFF C080080000000000_00 -FFFFFFBFFFFFEFEE C250000004048000_00 -F6FD7542899C1C6F C3A205157AECC7C8_01 -FFFFFFFFFFFFFBFF C090040000000000_00 -FF800000004001FF C35FFFFFFFEFFF81_01 -0000000002BE4932 4185F24990000000_00 -FFFFFFFFFFFFF7FF C0A0020000000000_00 -00001004000FFFFE 42B004000FFFFE00_00 -FFFFFF9DAA0123E0 C258957FB7080000_00 -FFFFFFFFFFFFEFFF C0B0010000000000_00 -00000001FDFFFDFE 41FFDFFFDFE00000_00 -FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 -FFFFFFFFFFFFDFFF C0C0008000000000_00 -FE0FE00000000000 C37F020000000000_00 -0779ED944A4E2779 439DE7B65129389D_01 -FFFFFFFFFFFFBFFF C0D0004000000000_00 -FBFFFE0400000000 C3900007F0000000_00 -0000010127E03666 4270127E03666000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -FFFFF0200000FFFE C2AFBFFFFE000400_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEFFFF C0F0001000000000_00 -FFEFFE0000080000 C33001FFFFF80000_00 -FFFFFFFFFD3354EA C1866558B0000000_00 -FFFFFFFFFFFDFFFF C100000800000000_00 -003FF0000003FFFE 434FF8000001FFFF_00 -0000006375B23F7B 4258DD6C8FDEC000_00 -FFFFFFFFFFFBFFFF C110000400000000_00 -000407FFFFFFFFF6 43101FFFFFFFFFD8_00 -0000000092117F38 41E2422FE7000000_00 -FFFFFFFFFFF7FFFF C120000200000000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -00000000000008BE 40A17C0000000000_00 -FFFFFFFFFFEFFFFF C130000100000000_00 -004000020FFFFFFF 4350000083FFFFFF_01 -FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 -FFFFFFFFFFDFFFFF C140000080000000_00 -00FFFFFFFFFFFFFD 436FFFFFFFFFFFFF_01 -00000023C2C6F284 4241E16379420000_00 -FFFFFFFFFFBFFFFF C150000040000000_00 -FFFDDFFFFFFFFFFD C301000000000018_00 -00000000746356C4 41DD18D5B1000000_00 -FFFFFFFFFF7FFFFF C160000020000000_00 -010000000000BFFF 4370000000000BFF_01 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFEFFFFFF C170000010000000_00 -FFFFBF7FFBFFFFFE C2D0200100000080_00 -00000006386CE889 4218E1B3A2240000_00 -FFFFFFFFFDFFFFFF C180000008000000_00 -F00000F7FFFFFFFF C3AFFFFE10000001_01 -FFFDFC53090C46A4 C3001D67B79DCAE0_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -0000000000800047 41600008E0000000_00 -FFFFFFFFD693872E C1C4B63C69000000_00 -FFFFFFFFF7FFFFFF C1A0000002000000_00 -000000007FBFFBFF 41DFEFFEFFC00000_00 -00000026A7845E35 424353C22F1A8000_00 -FFFFFFFFEFFFFFFF C1B0000001000000_00 -FFFFFFDFFFFFFBFD C240000002018000_00 -000000001433D14C 41B433D14C000000_00 -FFFFFFFFDFFFFFFF C1C0000000800000_00 -0001FFFFFFE0000E 42FFFFFFFE0000E0_00 -F0F23E8068D3D84A C3AE1B82FF2E5850_01 -FFFFFFFFBFFFFFFF C1D0000000400000_00 -F7FFBFFFFFFFBFFF C3A0008000000081_01 -FFFFBD29B7459087 C2D0B5922E9BDE40_00 -FFFFFFFF7FFFFFFF C1E0000000200000_00 -FFFFFFF8FFFFBFFF C21C000100040000_00 -FFFFFFFFFFEDDC06 C13223FA00000000_00 -FFFFFFFEFFFFFFFF C1F0000000100000_00 -FFFFFFF80001FFFF C21FFFF800040000_00 -0000000000002FF9 40C7FC8000000000_00 -FFFFFFFDFFFFFFFF C200000000080000_00 -004000040000FFFF 4350000100003FFF_01 -FFFFFFFFFFFFFFF1 C02E000000000000_00 -FFFFFFFBFFFFFFFF C210000000040000_00 -C0000000007FFFFA C3CFFFFFFFFFC001_01 -FFFFFFFFFE053E2B C17FAC1D50000000_00 -FFFFFFF7FFFFFFFF C220000000020000_00 -7FFE000007FFFFFF 43DFFF800001FFFF_01 -000000000000000D 402A000000000000_00 -FFFFFFEFFFFFFFFF C230000000010000_00 -F80000000001007E C39FFFFFFFFFFBFF_01 -FFFFED48424AD9D6 C2B2B7BDB5262A00_00 -FFFFFFDFFFFFFFFF C240000000008000_00 -FFFFFE0001FEFFFF C27FFFE010001000_00 -000000000000013B 4073B00000000000_00 -FFFFFFBFFFFFFFFF C250000000004000_00 -0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 -4A16BD4128090C83 43D285AF504A0243_01 -FFFFFF7FFFFFFFFF C260000000002000_00 -00FFF7FFFF7FFFFE 436FFEFFFFEFFFFF_01 -0000000000000006 4018000000000000_00 -FFFFFEFFFFFFFFFF C270000000001000_00 -FBFFFFBFFFBFFFFF C390000100010001_01 -00000000000001BA 407BA00000000000_00 -FFFFFDFFFFFFFFFF C280000000000800_00 -0000000040000082 41D0000020800000_00 -FF07A2BF5B689F89 C36F0BA81492EC0F_01 -FFFFFBFFFFFFFFFF C290000000000400_00 -0000001FF8000008 423FF80000080000_00 -F87CAA7DE672DE8B C39E0D5608663486_01 -FFFFF7FFFFFFFFFF C2A0000000000200_00 -07FFF80000000002 439FFFE000000000_01 -0000000010A1E5B8 41B0A1E5B8000000_00 -FFFFEFFFFFFFFFFF C2B0000000000100_00 -F7FFFFE00007FFFF C3A000003FFFF001_01 -FFFFFFFFFFF6ADFC C122A40800000000_00 -FFFFDFFFFFFFFFFF C2C0000000000080_00 -FFFFFF03FFFFFFC0 C26F800000080000_00 -EA579475948F0032 C3B5A86B8A6B7100_01 -FFFFBFFFFFFFFFFF C2D0000000000040_00 -FC00000000003FF6 C38FFFFFFFFFFE01_01 -002E677AC313BF60 434733BD6189DFB0_00 -FFFF7FFFFFFFFFFF C2E0000000000020_00 -02000007FF7FFFFF 438000003FFBFFFF_01 -0000000E999639F1 422D332C73E20000_00 -FFFEFFFFFFFFFFFF C2F0000000000010_00 -FFFF83FFFFFFFFBE C2DF000000001080_00 -000000000001537D 40F537D000000000_00 -FFFDFFFFFFFFFFFF C300000000000008_00 -EFFFFFC00000003D C3B0000040000000_01 -FFFFFFF21FEDFD35 C22BC02405960000_00 -FFFBFFFFFFFFFFFF C310000000000004_00 -FFFFFFF0000007FE C22FFFFFF0040000_00 -FFFFFFFFFFDE0839 C140FBE380000000_00 -FFF7FFFFFFFFFFFF C320000000000002_00 -0000007FFFE000FF 425FFFF8003FC000_00 -FFFFFFFF79F30F48 C1E0C19E17000000_00 -FFEFFFFFFFFFFFFF C330000000000001_00 -FFFFFC13FFFFFFFD C28F600000001800_00 -0000000000001B85 40BB850000000000_00 -FFDFFFFFFFFFFFFF C340000000000001_01 -000008000007FFFE 42A000000FFFFC00_00 -12DB4409E5AE87E6 43B2DB4409E5AE87_01 -FFBFFFFFFFFFFFFF C350000000000001_01 -FFFFFFFFFFF7BFEE C120802400000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FF7FFFFFFFFFFFFF C360000000000001_01 -000000001040FFFE 41B040FFFE000000_00 -00000909A09C13D3 42A213413827A600_00 -FEFFFFFFFFFFFFFF C370000000000001_01 -FFFFFF01FFFFFF7F C26FC00000102000_00 -FFFFFF72E7D2575D C261A305B5146000_00 -FDFFFFFFFFFFFFFF C380000000000001_01 -FFFFFFFFFFFEFFDB C0F0025000000000_00 -0000000000000017 4037000000000000_00 -FBFFFFFFFFFFFFFF C390000000000001_01 -100000001FFFFFF6 43B00000001FFFFF_01 -000000114B12EF51 42314B12EF510000_00 -F7FFFFFFFFFFFFFF C3A0000000000001_01 -0407FFFFFFFFFEFF 43901FFFFFFFFFFB_01 -FFFFFF769F3A5C2C C2612C18B47A8000_00 -EFFFFFFFFFFFFFFF C3B0000000000001_01 -FFFFFFFDF7FFFFFD C200400000180000_00 -FFFFFFFFFFFFFFF2 C02C000000000000_00 -DFFFFFFFFFFFFFFF C3C0000000000001_01 -FFFFFFFFFE0007FF C17FFF8010000000_00 -000000000000001E 403E000000000000_00 -BFFFFFFFFFFFFFFF C3D0000000000001_01 -FFF800000009FFFF C31FFFFFFFD80004_00 -0000000000007AA4 40DEA90000000000_00 -7FFFFFFFFFFFFFFF 43DFFFFFFFFFFFFF_01 -4080000000FFFFFF 43D0200000003FFF_01 -000000000DE7601D 41ABCEC03A000000_00 -3FFFFFFFFFFFFFFF 43CFFFFFFFFFFFFF_01 -FFCFFFFFFFBFFFFE C348000000200001_00 -FFFFFFFFFFFFFFCA C04B000000000000_00 -1FFFFFFFFFFFFFFF 43BFFFFFFFFFFFFF_01 -000080400000003F 42E00800000007E0_00 -00000000001F75A5 413F75A500000000_00 -0FFFFFFFFFFFFFFF 43AFFFFFFFFFFFFF_01 -FFFFFFEFFFFFCFFE C230000030020000_00 -FFFFFEE775887420 C27188A778BE0000_00 -07FFFFFFFFFFFFFF 439FFFFFFFFFFFFF_01 -00000000000801FE 412003FC00000000_00 -0000000000213FF1 41409FF880000000_00 -03FFFFFFFFFFFFFF 438FFFFFFFFFFFFF_01 -07FEFFFFFFFFFFEE 439FFBFFFFFFFFFF_01 -0000000000000004 4010000000000000_00 -01FFFFFFFFFFFFFF 437FFFFFFFFFFFFF_01 -0000000820000003 4220400000060000_00 -FFFFFFF9AD105214 C2194BBEB7B00000_00 -00FFFFFFFFFFFFFF 436FFFFFFFFFFFFF_01 -FFFFF00FFFFFFFBE C2AFE00000008400_00 -FFFFFFFFFFCC48E7 C149DB8C80000000_00 -007FFFFFFFFFFFFF 435FFFFFFFFFFFFF_01 -00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 -FFFFFFFFFF0BA6CB C16E8B26A0000000_00 -003FFFFFFFFFFFFF 434FFFFFFFFFFFFF_01 -FFFFFF7FBFFFFFBF C260080000082000_00 -FFFFFFFFFFF24425 C12B77B600000000_00 -001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 -200000001FFBFFFF 43C00000000FFDFF_01 -FFFFFF4E7115EC53 C26631DD4275A000_00 -000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 -FFFFF803FFFFFFBF C29FF00000010400_00 -FFFFFC2E539ADCFE C28E8D6329181000_00 -0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -00000055084732F3 42554211CCBCC000_00 -0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 -BFFF7FFFFFFFFE00 C3D0002000000001_01 -FFFFFFFFFFFF8543 C0DEAF4000000000_00 -0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 -0000001FFBFFE000 423FFBFFE0000000_00 -FFFFFFFFFFFE491B C0FB6E5000000000_00 -0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 -FC00200000001FFE C38FFEFFFFFFFF01_01 -FFFFF16898822A24 C2AD2ECEFBABB800_00 -00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 -3FFF03FFFFFFFFFE 43CFFF81FFFFFFFF_01 -FFFFFF8FFE18C7BF C25C0079CE104000_00 -00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 -FFFFFEFFFEFFFFFD C270001000003000_00 -00F03620C1266ED9 436E06C41824CDDB_01 -00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 -BF7EFFFFFFFFFFFF C3D0204000000001_01 -FFFFFFFFFFFFFFD5 C045800000000000_00 -00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 -FFFBFFFFF803FFFE C31000001FF00008_00 -0000000000068684 411A1A1000000000_00 -000007FFFFFFFFFF 429FFFFFFFFFFC00_00 -DFFFFFE00000001E C3C0000010000000_01 -FFFFFFFFFFFFECF5 C0B30B0000000000_00 -000003FFFFFFFFFF 428FFFFFFFFFF800_00 -FFFF00400000FFFF C2EFF7FFFFE00020_00 -0000000000000002 4000000000000000_00 -000001FFFFFFFFFF 427FFFFFFFFFF000_00 -FBFFFFFFFFFFBDFE C390000000000109_01 -0000000000000BC9 40A7920000000000_00 -000000FFFFFFFFFF 426FFFFFFFFFE000_00 -807FFFFFFFFFDFFE C3DFE00000000009_01 -FFC274E35A70CD76 C34EC58E52C79945_00 -0000007FFFFFFFFF 425FFFFFFFFFC000_00 -0FFFFFFFFEFFFFFD 43AFFFFFFFFDFFFF_01 -FFFFFFFF00E73AFC C1EFE318A0800000_00 -0000003FFFFFFFFF 424FFFFFFFFF8000_00 -FFC000000001000E C34FFFFFFFFF7FF9_00 -FFFFFFFFFFFE15E9 C0FEA17000000000_00 -0000001FFFFFFFFF 423FFFFFFFFF0000_00 -0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 -0000000000000033 4049800000000000_00 -0000000FFFFFFFFF 422FFFFFFFFE0000_00 -000000001FFFBFFF 41BFFFBFFF000000_00 -FFFFFFEE6B141E1B C23194EBE1E50000_00 -00000007FFFFFFFF 421FFFFFFFFC0000_00 -FFFFFFFFF60007FF C1A3FFF002000000_00 -00000001AB310BA6 41FAB310BA600000_00 -00000003FFFFFFFF 420FFFFFFFF80000_00 -0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 -FFFFFFFFFFFFF195 C0ACD60000000000_00 -00000001FFFFFFFF 41FFFFFFFFF00000_00 -FFFFFFFF8000000B C1DFFFFFFD400000_00 -00000019BA8D5559 4239BA8D55590000_00 -00000000FFFFFFFF 41EFFFFFFFE00000_00 -FBFEFFFFFFFFFFF9 C390040000000001_01 -FFFFFFB6F062822D C25243E75F74C000_00 -000000007FFFFFFF 41DFFFFFFFC00000_00 -0001000000000082 42F0000000000820_00 -01CEAD9E2FB104A4 437CEAD9E2FB104A_01 -000000003FFFFFFF 41CFFFFFFF800000_00 -000003FFFFFFFF7C 428FFFFFFFFBE000_00 -FFFFFFFFFD681E78 C184BF0C40000000_00 -000000001FFFFFFF 41BFFFFFFF000000_00 -00002000400001FF 42C000200000FF80_00 -0000000000000018 4038000000000000_00 -000000000FFFFFFF 41AFFFFFFE000000_00 -3FFF80000000003E 43CFFFC000000000_01 -FFFFFFFFFFFFFF95 C05AC00000000000_00 -0000000007FFFFFF 419FFFFFFC000000_00 -010000BFFFFFFFFF 4370000BFFFFFFFF_01 -0000001697087B19 423697087B190000_00 -0000000003FFFFFF 418FFFFFF8000000_00 -FBFFFFFFFFEEFFFD C390000000004401_01 -0000000E64BDFC55 422CC97BF8AA0000_00 -0000000001FFFFFF 417FFFFFF0000000_00 -FC00000001FFFFFE C38FFFFFFFF00001_01 -FFFED156A62AB849 C2F2EA959D547B70_00 -0000000000FFFFFF 416FFFFFE0000000_00 -FFFFFFF83FEFFFFD C21F0040000C0000_00 -00015354EAE7C259 42F5354EAE7C2590_00 -00000000007FFFFF 415FFFFFC0000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFF0F4DF3C75 C22E164187160000_00 -00000000003FFFFF 414FFFFF80000000_00 -FFFA000000001FFF C317FFFFFFFF8004_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000001FFFFF 413FFFFF00000000_00 -FFFFFFFFFF7FFE40 C160003800000000_00 -FFFFFFDB5433CB9B C24255E61A328000_00 -00000000000FFFFF 412FFFFE00000000_00 -FFFFFDFFDFFDFFFD C280010010001800_00 -FFFFFFFFFFDEAE1F C140A8F080000000_00 -000000000007FFFF 411FFFFC00000000_00 -FFFFFFFFF0080006 C1AFEFFFF4000000_00 -FFFFFFFE7735DEC7 C1F88CA213900000_00 -000000000003FFFF 410FFFF800000000_00 -00000001FBFFFFFF 41FFBFFFFFF00000_00 -000003757D8B12ED 428BABEC58976800_00 -000000000001FFFF 40FFFFF000000000_00 -FFFFFE07F7FFFFFF C27F808000001000_00 -00000A654064E046 42A4CA80C9C08C00_00 -000000000000FFFF 40EFFFE000000000_00 -08000000000017FF 43A000000000002F_01 -FFFFFFFFFFFFFFE7 C039000000000000_00 -0000000000007FFF 40DFFFC000000000_00 -07FFFFFFFFFFFDF6 439FFFFFFFFFFFF7_01 -FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 -0000000000003FFF 40CFFF8000000000_00 -0000300004000000 42C8000200000000_00 -FFFFFFF70B77F34F C221E91019620000_00 -0000000000001FFF 40BFFF0000000000_00 -FFFFFF80006FFFFE C25FFFE400008000_00 -0000013EB4D67EC8 4273EB4D67EC8000_00 -0000000000000FFF 40AFFE0000000000_00 -BFFFDFFFFBFFFFFF C3D0000800010001_01 -0005CEAF34EA1DC7 43173ABCD3A8771C_00 -00000000000007FF 409FFC0000000000_00 -00004800007FFFFD 42D200001FFFFF40_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000000003FF 408FF80000000000_00 -0000000200001000 4200000080000000_00 -00000000000360D0 410B068000000000_00 -00000000000001FF 407FF00000000000_00 -01003FFFFFFFFFFC 437003FFFFFFFFFF_01 -00C000708FF1BA51 4368000E11FE374A_01 -00000000000000FF 406FE00000000000_00 -F802000003FFFFFF C39FF7FFFFF00001_01 -0F9E07DCC0BDC061 43AF3C0FB9817B80_01 -000000000000007F 405FC00000000000_00 -03FF0000000000FF 438FF80000000007_01 -FFFFFFE1B9B2A079 C23E464D5F870000_00 -000000000000003F 404F800000000000_00 -FFF80000000080FF C31FFFFFFFFDFC04_00 -00000000001EB5B4 413EB5B400000000_00 -000000000000001F 403F000000000000_00 -000000000077FBFE 415DFEFF80000000_00 -00000000005AC607 4156B181C0000000_00 -000000000000000F 402E000000000000_00 -FFFFFFFEF80000FF C1F07FFFF0100000_00 -000005C5B9D66984 429716E759A61000_00 -0000000000000007 401C000000000000_00 -C001FFFFFFF00000 C3CFFF0000000800_00 -00001D06B372AA06 42BD06B372AA0600_00 -0000000000000003 4008000000000000_00 +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFD_01 +0000000032CC8B7A_41C96645BD000000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_C1CFFFE001000000_00 +032C857F319EDE38_4389642BF98CF6F1_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_C29000001FFF0800_00 +00394C79B6D3007B_434CA63CDB69803D_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_C39000003FFFFFF9_01 +0000000001AE458D_417AE458D0000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +F9EB456140D88764_C39852EA7AFC9DE3_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_C2BBFF0000000200_00 +07DE834A248EDF36_439F7A0D28923B7C_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +FFFFFFFFFFE385E2_C13C7A1E00000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_C3AFF7C000000001_01 +000000059EB1FD45_42167AC7F5140000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_C108003800000000_00 +FFFFFFFFFFFEDDFE_C0F2202000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000000C89FF56B_41E913FEAD600000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0_43BB5E4F0BE0DEBF_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_C3003FE000000008_00 +FFFFFFFFFFF4766B_C127132A00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000000C_4028000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +FFE662A109109D0A_C3399D5EF6EF62F6_00 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_C3CFFFFFFFE40001_01 +FFFFFFFFFFFFFFE4_C03C000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_C39FFBFFFFFFC000_00 +FE114B79075F70EE_C37EEB486F8A08F2_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000100_01 +00000000000003AC_408D600000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +00000044A3A3DBE5_425128E8F6F94000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_C33FFFC100000001_00 +FFFFFFFFFFFF1A91_C0ECADE000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_C2A0780000000600_00 +0000000000003309_40C9848000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58_C065000000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_C240FF0000010000_00 +0000000000002980_40C4C00000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +000000000000005D_4057400000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8_C30B9EE12E98A940_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_C3BFFFFFFFFFC001_01 +FFFFFDE3C1DEC43C_C280E1F109DE2000_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_C2EFFFFE80000060_00 +000000000030FFBE_41487FDF00000000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_C2FFFFFF80010030_00 +FFFFFFFFEFDEED86_C1B021127A000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_C3A8000000008001_01 +000000001DA3FF45_41BDA3FF45000000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54_C1F64E434AC00000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +F27DD19DE6563714_C3AB045CC4335392_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_C34FFFFFFFDFFC01_00 +000000000001A359_40FA359000000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +FFFFFFFFFE62EC20_C179D13E00000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000285F_40C42F8000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_C1D00003FC400000_00 +FFFFF836F99DBAA8_C29F241989156000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0033466832042D47_4349A334190216A3_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_C09DE40000000000_00 +00000000003829C8_414C14E400000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000000FB77C672B_422F6EF8CE560000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFBFFFFFF_01 +0000000000001B78_40BB780000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_C360000000020401_01 +0000000000000071_405C400000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86_C05E800000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +FFF8A60D9E19F17E_C31D67C987983A08_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +FFFFFFFFF7506DBA_C1A15F248C000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_C0F0409000000000_00 +FFFFFFFFFEA42AC9_C175BD5370000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89_C33855C0D4253377_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9_C3004BF1099291B8_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_C2700001FFF81000_00 +FFFFFFFFFFFFCFBE_C0C8210000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +FEC01FECA24DE1B0_C373FE0135DB21E5_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_C3A0000000400101_01 +F858A66761669936_C39E9D66627A659C_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_C2F007FFFFFFFC20_00 +F716EA43FAC45C97_C3A1D22B780A7747_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_C04D000000000000_00 +0024D70EC7661FD8_43426B8763B30FEC_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_C3CFC00000000001_01 +FFD956DBD0AEE817_C343549217A88BF5_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F7FFFFFFF_01 +FFFFFFFFFFFF4300_C0E7A00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +C12EDF40F41F6021_C3CF68905F85F050_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_C35BFFFFFFFFFFF9_01 +FFFFFFF83DE950F6_C21F085ABC280000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_C3DFFFFF00000100_00 +FE2B59CB3A604D69_C37D4A634C59FB2A_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFEF_01 +000000A37C210862_42646F84210C4000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +FFFFB65CD8617789_C2D268C9E7A21DC0_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D_C0AFC60000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B000008000003F_01 +000000000D098D19_41AA131A32000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFAF_01 +000006B3BD2C7BEF_429ACEF4B1EFBC00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8_C2E634A444AB6B00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +FFFFFFFFFFFFFF21_C06BE00000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +FFFFFFFFFC648262_C18CDBECF0000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_C3CFFFF000000001_01 +FFFFFF7353AC45D2_C261958A7745C000_00 +8000000000000000_C3E0000000000000_00 +FFFFFFFFFFE7EFFF_C138100100000000_00 +0000000000A1202D_41642405A0000000_00 +C000000000000000_C3D0000000000000_00 +FFFFFFFFFFFF5F7F_C0E4102000000000_00 +000000000040CA70_4150329C00000000_00 +E000000000000000_C3C0000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000003B55D87D4_420DAAEC3EA00000_00 +F000000000000000_C3B0000000000000_00 +FF80000DFFFFFFFF_C35FFFFC80000001_01 +000000010510FAEF_41F0510FAEF00000_00 +F800000000000000_C3A0000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000000724A_40DC928000000000_00 +FC00000000000000_C390000000000000_00 +FFFFFFDF80000002_C2403FFFFFFF0000_00 +0000000000000064_4059000000000000_00 +FE00000000000000_C380000000000000_00 +FEFFFFFFFFF800FE_C370000000007FF1_01 +FFFFFFC2C6222702_C24E9CEEEC7F0000_00 +FF00000000000000_C370000000000000_00 +0000000408000002_4210200000080000_00 +000000E96DF1CB41_426D2DBE39682000_00 +FF80000000000000_C360000000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE7F_01 +F727F174DEE7DC85_C3A1B01D16423047_01 +FFC0000000000000_C350000000000000_00 +8000000003FFFEFE_C3DFFFFFFFFF0001_01 +FFFFFFFFFFF0BD5B_C12E854A00000000_00 +FFE0000000000000_C340000000000000_00 +0BEFFFFFFFFFFFFF_43A7DFFFFFFFFFFF_01 +000000000002790C_4103C86000000000_00 +FFF0000000000000_C330000000000000_00 +FFFFFFFFFFEFFBFA_C130040600000000_00 +000000169E75DF01_42369E75DF010000_00 +FFF8000000000000_C320000000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000000E_402C000000000000_00 +FFFC000000000000_C310000000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +FFFFFFFFFFF28622_C12AF3BC00000000_00 +FFFE000000000000_C300000000000000_00 +FFFFFF7FFFFDF7FF_C260000041002000_00 +00072F0EC496FE21_431CBC3B125BF884_00 +FFFF000000000000_C2F0000000000000_00 +DFBFFFFFFFFFFFFE_C3C0200000000001_01 +0000000000FC1FCA_416F83F940000000_00 +FFFF800000000000_C2E0000000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE_C2E5CD636AC7A640_00 +FFFFC00000000000_C2D0000000000000_00 +00000002100007FD_420080003FE80000_00 +FFFFFFFFFFC2D8FE_C14E938100000000_00 +FFFFE00000000000_C2C0000000000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000001766E_40F766E000000000_00 +FFFFF00000000000_C2B0000000000000_00 +0040000400000002_4350000100000000_01 +0000000000007841_40DE104000000000_00 +FFFFF80000000000_C2A0000000000000_00 +3DFFFFFFFFFFFF7E_43CEFFFFFFFFFFFF_01 +FFFFFFE549E17E30_C23AB61E81D00000_00 +FFFFFC0000000000_C290000000000000_00 +FFFFFFFFFFFFFEE1_C071F00000000000_00 +FFFFFFFFFFFFFFE7_C039000000000000_00 +FFFFFE0000000000_C280000000000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73_C061A00000000000_00 +FFFFFF0000000000_C270000000000000_00 +FD00000008000000_C387FFFFFFC00000_00 +000000000001DBB1_40FDBB1000000000_00 +FFFFFF8000000000_C260000000000000_00 +FFFFFFFFFFF8007F_C11FFE0400000000_00 +FFFFFFFEFD10A515_C1F02EF5AEB00000_00 +FFFFFFC000000000_C250000000000000_00 +FFEFFFFFFFFFFFFE_C330000000000002_00 +FAB02984F6283B6C_C3953F59EC275F13_01 +FFFFFFE000000000_C240000000000000_00 +FFFFFFBC000001FE_C250FFFFFF808000_00 +FEB087C6B9FE7FE0_C374F78394601802_00 +FFFFFFF000000000_C230000000000000_00 +FFF80001000007FE_C31FFFFBFFFFE008_00 +00F2762EA6837956_436E4EC5D4D06F2A_01 +FFFFFFF800000000_C220000000000000_00 +FFF7E0FFFFFFFFFE_C3203E0000000004_00 +00002E1175484626_42C708BAA4231300_00 +FFFFFFFC00000000_C210000000000000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000068F_409A3C0000000000_00 +FFFFFFFE00000000_C200000000000000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFDFFF_01 +FFFFFFFFFFFFFFF9_C01C000000000000_00 +FFFFFFFF00000000_C1F0000000000000_00 +FFFFFFD0000FFFFD_C247FFF800018000_00 +000000BDF6658B83_4267BECCB1706000_00 +FFFFFFFF80000000_C1E0000000000000_00 +1000001FFDFFFFFF_43B000001FFDFFFF_01 +0000000000003B5B_40CDAD8000000000_00 +FFFFFFFFC0000000_C1D0000000000000_00 +FFFFFFBFFE0FFFFF_C250007C00004000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +FFFFFFFFE0000000_C1C0000000000000_00 +FFFFFFFBF00007FF_C2103FFFE0040000_00 +01E986274F48EAAD_437E986274F48EAA_01 +FFFFFFFFF0000000_C1B0000000000000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFDFFFFFF_01 +FFFFFFFFFFFFCB5A_C0CA530000000000_00 +FFFFFFFFF8000000_C1A0000000000000_00 +7FF000000000FFFF_43DFFC000000003F_01 +00000003C2717FC3_420E138BFE180000_00 +FFFFFFFFFC000000_C190000000000000_00 +FFFFFFE00008001F_C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA_C130542600000000_00 +FFFFFFFFFE000000_C180000000000000_00 +0200000000000002_4380000000000000_01 +FFFFFFFFF8FDA53F_C19C096B04000000_00 +FFFFFFFFFF000000_C170000000000000_00 +F6000003FFFFFFFE_C3A3FFFFF8000001_01 +FFFFFFFFFFFFFFD0_C048000000000000_00 +FFFFFFFFFF800000_C160000000000000_00 +FFFFFFFFFFBFFF7E_C150002080000000_00 +00000000EE0FEA62_41EDC1FD4C400000_00 +FFFFFFFFFFC00000_C150000000000000_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000037F35EDC1D_424BF9AF6E0E8000_00 +FFFFFFFFFFE00000_C140000000000000_00 +FFFFFFF7FDFFFF7D_C220040001060000_00 +00000000000001AD_407AD00000000000_00 +FFFFFFFFFFF00000_C130000000000000_00 +FFFFFF0000100020_C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A_43C3F8B3FDE3FE2F_01 +FFFFFFFFFFF80000_C120000000000000_00 +003FFFFFFFFC0001_434FFFFFFFFE0000_01 +000E48F9F4EBD30E_432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000_C110000000000000_00 +DFFFFFFFFFFBFFFE_C3C0000000000201_01 +FC91C23EE8C9424F_C38B71EE08B9B5EE_01 +FFFFFFFFFFFE0000_C100000000000000_00 +F7DFFBFFFFFFFFFE_C3A0400800000001_01 +000000002CAE080C_41C6570406000000_00 +FFFFFFFFFFFF0000_C0F0000000000000_00 +FFFFC00010000020_C2CFFFF7FFFFF000_00 +04D921F917B20E40_43936487E45EC839_00 +FFFFFFFFFFFF8000_C0E0000000000000_00 +F8000FFFFFFFFFFD_C39FFFC000000001_01 +FFF17C566BC7D811_C32D075328704FDE_00 +FFFFFFFFFFFFC000_C0D0000000000000_00 +00000000000000FE_406FC00000000000_00 +FFF82AC14930D386_C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000_C0C0000000000000_00 +00000000000003FC_408FE00000000000_00 +000E62EC60E119FC_432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000_C0B0000000000000_00 +FFFFEFF7FF7FFFFE_C2B0080080000200_00 +0E2B1ECF210EEDC5_43AC563D9E421DDB_01 +FFFFFFFFFFFFF800_C0A0000000000000_00 +00000000007FFF1F_415FFFC7C0000000_00 +FFFFFE534F5676F7_C27ACB0A98909000_00 +FFFFFFFFFFFFFC00_C090000000000000_00 +0000001004FFFFFD_423004FFFFFD0000_00 +0000035C939669F1_428AE49CB34F8800_00 +FFFFFFFFFFFFFE00_C080000000000000_00 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFD_01 +FFFFFFFFFFFFFF91_C05BC00000000000_00 +FFFFFFFFFFFFFF00_C070000000000000_00 +01FFFFFFFBFFEFFE_437FFFFFFFBFFEFF_01 +000000000000016E_4076E00000000000_00 +FFFFFFFFFFFFFF80_C060000000000000_00 +FFF7FFFFFFFFF7FD_C320000000001006_00 +FFFFF8E2BCFAC553_C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0_C050000000000000_00 +FFFFFBFFFFFE0FFE_C290000007C00800_00 +00000001A4E704BF_41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0_C040000000000000_00 +1400007FFFFFFFFD_43B400007FFFFFFF_01 +FFFFFFFC93B187B4_C20B6273C2600000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +40000000007FFFFD_43D0000000001FFF_01 +000000000067D468_4159F51A00000000_00 +FFFFFFFFFFFFFFF8_C020000000000000_00 +007FFEFFFFFBFFFE_435FFFBFFFFEFFFF_01 +FFFFFFE26CEC79F8_C23D931386080000_00 +FFFFFFFFFFFFFFFC_C010000000000000_00 +00FFFFFF000000FF_436FFFFFE000001F_01 +FFFFFFFFE0D3983A_C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE_C000000000000000_00 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A_C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF_BFF0000000000000_00 +000008000000027E_42A000000004FC00_00 +000000000000F4E8_40EE9D0000000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFF83FFDF_C15F000840000000_00 +00000E11407887B2_42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +04000003FFFFFFF6_439000000FFFFFFF_01 +0000000000000513_40944C0000000000_00 +FFFFFFFFFFFFFFF7_C022000000000000_00 +BFFC00000000003E_C3D0010000000000_01 +00000008D7BBB75B_4221AF776EB60000_00 +FFFFFFFFFFFFFFEF_C031000000000000_00 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23_C14952EE80000000_00 +FFFFFFFFFFFFFFDF_C040800000000000_00 +FFBFDFFFBFFFFFFF_C350080010000001_01 +000000000000007F_405FC00000000000_00 +FFFFFFFFFFFFFFBF_C050400000000000_00 +00000007FF800003_421FFE00000C0000_00 +000000000002BB02_4105D81000000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEE7FF_C0F1801000000000_00 +00264B2B9BAD0DA2_43432595CDD686D1_00 +FFFFFFFFFFFFFEFF_C070100000000000_00 +0000000000100803_4130080300000000_00 +FF9B1DCB9F857D5E_C359388D181EA0A9_01 +FFFFFFFFFFFFFDFF_C080080000000000_00 +FFFFFFBFFFFFEFEE_C250000004048000_00 +F6FD7542899C1C6F_C3A205157AECC7C8_01 +FFFFFFFFFFFFFBFF_C090040000000000_00 +FF800000004001FF_C35FFFFFFFEFFF81_01 +0000000002BE4932_4185F24990000000_00 +FFFFFFFFFFFFF7FF_C0A0020000000000_00 +00001004000FFFFE_42B004000FFFFE00_00 +FFFFFF9DAA0123E0_C258957FB7080000_00 +FFFFFFFFFFFFEFFF_C0B0010000000000_00 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0_C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF_C0C0008000000000_00 +FE0FE00000000000_C37F020000000000_00 +0779ED944A4E2779_439DE7B65129389D_01 +FFFFFFFFFFFFBFFF_C0D0004000000000_00 +FBFFFE0400000000_C3900007F0000000_00 +0000010127E03666_4270127E03666000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +FFFFF0200000FFFE_C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEFFFF_C0F0001000000000_00 +FFEFFE0000080000_C33001FFFFF80000_00 +FFFFFFFFFD3354EA_C1866558B0000000_00 +FFFFFFFFFFFDFFFF_C100000800000000_00 +003FF0000003FFFE_434FF8000001FFFF_00 +0000006375B23F7B_4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF_C110000400000000_00 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000092117F38_41E2422FE7000000_00 +FFFFFFFFFFF7FFFF_C120000200000000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +00000000000008BE_40A17C0000000000_00 +FFFFFFFFFFEFFFFF_C130000100000000_00 +004000020FFFFFFF_4350000083FFFFFF_01 +FFFFB84C2D8BC9CB_C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF_C140000080000000_00 +00FFFFFFFFFFFFFD_436FFFFFFFFFFFFF_01 +00000023C2C6F284_4241E16379420000_00 +FFFFFFFFFFBFFFFF_C150000040000000_00 +FFFDDFFFFFFFFFFD_C301000000000018_00 +00000000746356C4_41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF_C160000020000000_00 +010000000000BFFF_4370000000000BFF_01 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFEFFFFFF_C170000010000000_00 +FFFFBF7FFBFFFFFE_C2D0200100000080_00 +00000006386CE889_4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF_C180000008000000_00 +F00000F7FFFFFFFF_C3AFFFFE10000001_01 +FFFDFC53090C46A4_C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +0000000000800047_41600008E0000000_00 +FFFFFFFFD693872E_C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF_C1A0000002000000_00 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000026A7845E35_424353C22F1A8000_00 +FFFFFFFFEFFFFFFF_C1B0000001000000_00 +FFFFFFDFFFFFFBFD_C240000002018000_00 +000000001433D14C_41B433D14C000000_00 +FFFFFFFFDFFFFFFF_C1C0000000800000_00 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +F0F23E8068D3D84A_C3AE1B82FF2E5850_01 +FFFFFFFFBFFFFFFF_C1D0000000400000_00 +F7FFBFFFFFFFBFFF_C3A0008000000081_01 +FFFFBD29B7459087_C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF_C1E0000000200000_00 +FFFFFFF8FFFFBFFF_C21C000100040000_00 +FFFFFFFFFFEDDC06_C13223FA00000000_00 +FFFFFFFEFFFFFFFF_C1F0000000100000_00 +FFFFFFF80001FFFF_C21FFFF800040000_00 +0000000000002FF9_40C7FC8000000000_00 +FFFFFFFDFFFFFFFF_C200000000080000_00 +004000040000FFFF_4350000100003FFF_01 +FFFFFFFFFFFFFFF1_C02E000000000000_00 +FFFFFFFBFFFFFFFF_C210000000040000_00 +C0000000007FFFFA_C3CFFFFFFFFFC001_01 +FFFFFFFFFE053E2B_C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF_C220000000020000_00 +7FFE000007FFFFFF_43DFFF800001FFFF_01 +000000000000000D_402A000000000000_00 +FFFFFFEFFFFFFFFF_C230000000010000_00 +F80000000001007E_C39FFFFFFFFFFBFF_01 +FFFFED48424AD9D6_C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF_C240000000008000_00 +FFFFFE0001FEFFFF_C27FFFE010001000_00 +000000000000013B_4073B00000000000_00 +FFFFFFBFFFFFFFFF_C250000000004000_00 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0243_01 +FFFFFF7FFFFFFFFF_C260000000002000_00 +00FFF7FFFF7FFFFE_436FFEFFFFEFFFFF_01 +0000000000000006_4018000000000000_00 +FFFFFEFFFFFFFFFF_C270000000001000_00 +FBFFFFBFFFBFFFFF_C390000100010001_01 +00000000000001BA_407BA00000000000_00 +FFFFFDFFFFFFFFFF_C280000000000800_00 +0000000040000082_41D0000020800000_00 +FF07A2BF5B689F89_C36F0BA81492EC0F_01 +FFFFFBFFFFFFFFFF_C290000000000400_00 +0000001FF8000008_423FF80000080000_00 +F87CAA7DE672DE8B_C39E0D5608663486_01 +FFFFF7FFFFFFFFFF_C2A0000000000200_00 +07FFF80000000002_439FFFE000000000_01 +0000000010A1E5B8_41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF_C2B0000000000100_00 +F7FFFFE00007FFFF_C3A000003FFFF001_01 +FFFFFFFFFFF6ADFC_C122A40800000000_00 +FFFFDFFFFFFFFFFF_C2C0000000000080_00 +FFFFFF03FFFFFFC0_C26F800000080000_00 +EA579475948F0032_C3B5A86B8A6B7100_01 +FFFFBFFFFFFFFFFF_C2D0000000000040_00 +FC00000000003FF6_C38FFFFFFFFFFE01_01 +002E677AC313BF60_434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF_C2E0000000000020_00 +02000007FF7FFFFF_438000003FFBFFFF_01 +0000000E999639F1_422D332C73E20000_00 +FFFEFFFFFFFFFFFF_C2F0000000000010_00 +FFFF83FFFFFFFFBE_C2DF000000001080_00 +000000000001537D_40F537D000000000_00 +FFFDFFFFFFFFFFFF_C300000000000008_00 +EFFFFFC00000003D_C3B0000040000000_01 +FFFFFFF21FEDFD35_C22BC02405960000_00 +FFFBFFFFFFFFFFFF_C310000000000004_00 +FFFFFFF0000007FE_C22FFFFFF0040000_00 +FFFFFFFFFFDE0839_C140FBE380000000_00 +FFF7FFFFFFFFFFFF_C320000000000002_00 +0000007FFFE000FF_425FFFF8003FC000_00 +FFFFFFFF79F30F48_C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF_C330000000000001_00 +FFFFFC13FFFFFFFD_C28F600000001800_00 +0000000000001B85_40BB850000000000_00 +FFDFFFFFFFFFFFFF_C340000000000001_01 +000008000007FFFE_42A000000FFFFC00_00 +12DB4409E5AE87E6_43B2DB4409E5AE87_01 +FFBFFFFFFFFFFFFF_C350000000000001_01 +FFFFFFFFFFF7BFEE_C120802400000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FF7FFFFFFFFFFFFF_C360000000000001_01 +000000001040FFFE_41B040FFFE000000_00 +00000909A09C13D3_42A213413827A600_00 +FEFFFFFFFFFFFFFF_C370000000000001_01 +FFFFFF01FFFFFF7F_C26FC00000102000_00 +FFFFFF72E7D2575D_C261A305B5146000_00 +FDFFFFFFFFFFFFFF_C380000000000001_01 +FFFFFFFFFFFEFFDB_C0F0025000000000_00 +0000000000000017_4037000000000000_00 +FBFFFFFFFFFFFFFF_C390000000000001_01 +100000001FFFFFF6_43B00000001FFFFF_01 +000000114B12EF51_42314B12EF510000_00 +F7FFFFFFFFFFFFFF_C3A0000000000001_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFB_01 +FFFFFF769F3A5C2C_C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF_C3B0000000000001_01 +FFFFFFFDF7FFFFFD_C200400000180000_00 +FFFFFFFFFFFFFFF2_C02C000000000000_00 +DFFFFFFFFFFFFFFF_C3C0000000000001_01 +FFFFFFFFFE0007FF_C17FFF8010000000_00 +000000000000001E_403E000000000000_00 +BFFFFFFFFFFFFFFF_C3D0000000000001_01 +FFF800000009FFFF_C31FFFFFFFD80004_00 +0000000000007AA4_40DEA90000000000_00 +7FFFFFFFFFFFFFFF_43DFFFFFFFFFFFFF_01 +4080000000FFFFFF_43D0200000003FFF_01 +000000000DE7601D_41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF_43CFFFFFFFFFFFFF_01 +FFCFFFFFFFBFFFFE_C348000000200001_00 +FFFFFFFFFFFFFFCA_C04B000000000000_00 +1FFFFFFFFFFFFFFF_43BFFFFFFFFFFFFF_01 +000080400000003F_42E00800000007E0_00 +00000000001F75A5_413F75A500000000_00 +0FFFFFFFFFFFFFFF_43AFFFFFFFFFFFFF_01 +FFFFFFEFFFFFCFFE_C230000030020000_00 +FFFFFEE775887420_C27188A778BE0000_00 +07FFFFFFFFFFFFFF_439FFFFFFFFFFFFF_01 +00000000000801FE_412003FC00000000_00 +0000000000213FF1_41409FF880000000_00 +03FFFFFFFFFFFFFF_438FFFFFFFFFFFFF_01 +07FEFFFFFFFFFFEE_439FFBFFFFFFFFFF_01 +0000000000000004_4010000000000000_00 +01FFFFFFFFFFFFFF_437FFFFFFFFFFFFF_01 +0000000820000003_4220400000060000_00 +FFFFFFF9AD105214_C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF_436FFFFFFFFFFFFF_01 +FFFFF00FFFFFFFBE_C2AFE00000008400_00 +FFFFFFFFFFCC48E7_C149DB8C80000000_00 +007FFFFFFFFFFFFF_435FFFFFFFFFFFFF_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB_C16E8B26A0000000_00 +003FFFFFFFFFFFFF_434FFFFFFFFFFFFF_01 +FFFFFF7FBFFFFFBF_C260080000082000_00 +FFFFFFFFFFF24425_C12B77B600000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFDFF_01 +FFFFFF4E7115EC53_C26631DD4275A000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_C29FF00000010400_00 +FFFFFC2E539ADCFE_C28E8D6329181000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +00000055084732F3_42554211CCBCC000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_C3D0002000000001_01 +FFFFFFFFFFFF8543_C0DEAF4000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +FFFFFFFFFFFE491B_C0FB6E5000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_C38FFEFFFFFFFF01_01 +FFFFF16898822A24_C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF81FFFFFFFF_01 +FFFFFF8FFE18C7BF_C25C0079CE104000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_C270001000003000_00 +00F03620C1266ED9_436E06C41824CDDB_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_C3D0204000000001_01 +FFFFFFFFFFFFFFD5_C045800000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_C31000001FF00008_00 +0000000000068684_411A1A1000000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_C3C0000010000000_01 +FFFFFFFFFFFFECF5_C0B30B0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_C2EFF7FFFFE00020_00 +0000000000000002_4000000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_C390000000000109_01 +0000000000000BC9_40A7920000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_C3DFE00000000009_01 +FFC274E35A70CD76_C34EC58E52C79945_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFDFFFF_01 +FFFFFFFF00E73AFC_C1EFE318A0800000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9_C0FEA17000000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +0000000000000033_4049800000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +FFFFFFEE6B141E1B_C23194EBE1E50000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_C1A3FFF002000000_00 +00000001AB310BA6_41FAB310BA600000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195_C0ACD60000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_C1DFFFFFFD400000_00 +00000019BA8D5559_4239BA8D55590000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_C390040000000001_01 +FFFFFFB6F062822D_C25243E75F74C000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +01CEAD9E2FB104A4_437CEAD9E2FB104A_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +FFFFFFFFFD681E78_C184BF0C40000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000018_4038000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000000_01 +FFFFFFFFFFFFFF95_C05AC00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000BFFFFFFFF_01 +0000001697087B19_423697087B190000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_C390000000004401_01 +0000000E64BDFC55_422CC97BF8AA0000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_C38FFFFFFFF00001_01 +FFFED156A62AB849_C2F2EA959D547B70_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_C21F0040000C0000_00 +00015354EAE7C259_42F5354EAE7C2590_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFF0F4DF3C75_C22E164187160000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_C160003800000000_00 +FFFFFFDB5433CB9B_C24255E61A328000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_C280010010001800_00 +FFFFFFFFFFDEAE1F_C140A8F080000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7_C1F88CA213900000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000003757D8B12ED_428BABEC58976800_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_C27F808000001000_00 +00000A654064E046_42A4CA80C9C08C00_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A000000000002F_01 +FFFFFFFFFFFFFFE7_C039000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF7_01 +FFFFAD78B3D6C3B6_C2D4A1D30A4F1280_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +FFFFFFF70B77F34F_C221E91019620000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_C25FFFE400008000_00 +0000013EB4D67EC8_4273EB4D67EC8000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_C3D0000800010001_01 +0005CEAF34EA1DC7_43173ABCD3A8771C_00 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000360D0_410B068000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_437003FFFFFFFFFF_01 +00C000708FF1BA51_4368000E11FE374A_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_C39FF7FFFFF00001_01 +0F9E07DCC0BDC061_43AF3C0FB9817B80_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000007_01 +FFFFFFE1B9B2A079_C23E464D5F870000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_C31FFFFFFFFDFC04_00 +00000000001EB5B4_413EB5B400000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +00000000005AC607_4156B181C0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_C1F07FFFF0100000_00 +000005C5B9D66984_429716E759A61000_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_C3CFFF0000000800_00 +00001D06B372AA06_42BD06B372AA0600_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_rne.tv b/wally-pipelined/testbench/fp/i64_f64_rne.tv index ed6b0a3ac..08859f243 100644 --- a/wally-pipelined/testbench/fp/i64_f64_rne.tv +++ b/wally-pipelined/testbench/fp/i64_f64_rne.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 439FFFF7FFFFFFFE_01 -0000000032CC8B7A 41C96645BD000000_00 -0000000000000000 0000000000000000_00 -FFFFFFFFC0003FFE C1CFFFE001000000_00 -032C857F319EDE38 4389642BF98CF6F2_01 -0000000000000001 3FF0000000000000_00 -FFFFFBFFFFF8003E C29000001FFF0800_00 -00394C79B6D3007B 434CA63CDB69803E_01 -0000000000000002 4000000000000000_00 -FBFFFFF0000001FF C39000003FFFFFF8_01 -0000000001AE458D 417AE458D0000000_00 -0000000000000004 4010000000000000_00 -00040008000007FE 4310002000001FF8_00 -F9EB456140D88764 C39852EA7AFC9DE2_01 -0000000000000008 4020000000000000_00 -FFFFE400FFFFFFFE C2BBFF0000000200_00 -07DE834A248EDF36 439F7A0D28923B7D_01 -0000000000000010 4030000000000000_00 -00000003FF001FFF 420FF800FFF80000_00 -FFFFFFFFFFE385E2 C13C7A1E00000000_00 -0000000000000020 4040000000000000_00 -F0041FFFFFFFFFFF C3AFF7C000000000_01 -000000059EB1FD45 42167AC7F5140000_00 -0000000000000040 4050000000000000_00 -FFFFFFFFFFFCFFF9 C108003800000000_00 -FFFFFFFFFFFEDDFE C0F2202000000000_00 -0000000000000080 4060000000000000_00 -000000000003FF00 410FF80000000000_00 -00000000C89FF56B 41E913FEAD600000_00 -0000000000000100 4070000000000000_00 -000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 -1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEC0_01 -0000000000000200 4080000000000000_00 -FFFDF803FFFFFFFF C3003FE000000008_00 -FFFFFFFFFFF4766B C127132A00000000_00 -0000000000000400 4090000000000000_00 -0000080100000FFE 42A00200001FFC00_00 -000000000000000C 4028000000000000_00 -0000000000000800 40A0000000000000_00 -0048000000100000 4352000000040000_00 -FFE662A109109D0A C3399D5EF6EF62F6_00 -0000000000001000 40B0000000000000_00 -C000000037FFFFFE C3CFFFFFFFE40000_01 -FFFFFFFFFFFFFFE4 C03C000000000000_00 -0000000000002000 40C0000000000000_00 -F801000000100000 C39FFBFFFFFFC000_00 -FE114B79075F70EE C37EEB486F8A08F1_01 -0000000000004000 40D0000000000000_00 -100000000001003E 43B0000000000100_01 -00000000000003AC 408D600000000000_00 -0000000000008000 40E0000000000000_00 -200000FFFFFFF800 43C000007FFFFFFC_00 -00000044A3A3DBE5 425128E8F6F94000_00 -0000000000010000 40F0000000000000_00 -FFE0003EFFFFFFFF C33FFFC100000001_00 -FFFFFFFFFFFF1A91 C0ECADE000000000_00 -0000000000020000 4100000000000000_00 -FFFFF7C3FFFFFFFD C2A0780000000600_00 -0000000000003309 40C9848000000000_00 -0000000000040000 4110000000000000_00 -000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 -FFFFFFFFFFFFFF58 C065000000000000_00 -0000000000080000 4120000000000000_00 -FFFFFFDE01FFFFFE C240FF0000010000_00 -0000000000002980 40C4C00000000000_00 -0000000000100000 4130000000000000_00 -00000000FFF07FFF 41EFFE0FFFE00000_00 -000000000000005D 4057400000000000_00 -0000000000200000 4140000000000000_00 -000020FFDFFFFFFF 42C07FEFFFFFFF80_00 -FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 -0000000000400000 4150000000000000_00 -E0000000003FFFDF C3BFFFFFFFFFC000_01 -FFFFFDE3C1DEC43C C280E1F109DE2000_00 -0000000000800000 4160000000000000_00 -FFFF00000BFFFFFD C2EFFFFE80000060_00 -000000000030FFBE 41487FDF00000000_00 -0000000001000000 4170000000000000_00 -FFFE000007FFEFFD C2FFFFFF80010030_00 -FFFFFFFFEFDEED86 C1B021127A000000_00 -0000000002000000 4180000000000000_00 -F3FFFFFFFFBFFFFE C3A8000000008000_01 -000000001DA3FF45 41BDA3FF45000000_00 -0000000004000000 4190000000000000_00 -FFFFFFFF00010007 C1EFFFDFFF200000_00 -FFFFFFFE9B1BCB54 C1F64E434AC00000_00 -0000000008000000 41A0000000000000_00 -00004000004001FE 42D0000010007F80_00 -F27DD19DE6563714 C3AB045CC4335392_01 -0000000010000000 41B0000000000000_00 -FFC00000004007FE C34FFFFFFFDFFC01_00 -000000000001A359 40FA359000000000_00 -0000000020000000 41C0000000000000_00 -0000000003C000FE 418E0007F0000000_00 -FFFFFFFFFE62EC20 C179D13E00000000_00 -0000000040000000 41D0000000000000_00 -000000003FFFFFFD 41CFFFFFFE800000_00 -000000000000285F 40C42F8000000000_00 -0000000080000000 41E0000000000000_00 -FFFFFFFFBFFFF00F C1D00003FC400000_00 -FFFFF836F99DBAA8 C29F241989156000_00 -0000000100000000 41F0000000000000_00 -00000020003FFEFE 4240001FFF7F0000_00 -0033466832042D47 4349A334190216A4_01 -0000000200000000 4200000000000000_00 -FFFFFFFFFFFFF887 C09DE40000000000_00 -00000000003829C8 414C14E400000000_00 -0000000400000000 4210000000000000_00 -00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 -0000000FB77C672B 422F6EF8CE560000_00 -0000000800000000 4220000000000000_00 -08003FFDFFFFFFFE 43A0007FFC000000_01 -0000000000001B78 40BB780000000000_00 -0000001000000000 4230000000000000_00 -FF7FFFFFFFEFDFFF C360000000020400_01 -0000000000000071 405C400000000000_00 -0000002000000000 4240000000000000_00 -000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 -FFFFFFFFFFFFFF86 C05E800000000000_00 -0000004000000000 4250000000000000_00 -0800000000040800 43A0000000000810_00 -FFF8A60D9E19F17E C31D67C987983A08_00 -0000008000000000 4260000000000000_00 -000077FFF0000000 42DDFFFC00000000_00 -FFFFFFFFF7506DBA C1A15F248C000000_00 -0000010000000000 4270000000000000_00 -FFFFFFFFFFFEFBF7 C0F0409000000000_00 -FFFFFFFFFEA42AC9 C175BD5370000000_00 -0000020000000000 4280000000000000_00 -0000107FFFFFDFFD 42B07FFFFFDFFD00_00 -FFE7AA3F2BDACC89 C33855C0D4253377_00 -0000040000000000 4290000000000000_00 -FFF8040000040000 C31FEFFFFFF00000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -0000080000000000 42A0000000000000_00 -FFFF80000800001F C2DFFFFDFFFFF840_00 -FFFDF681DECDADC9 C3004BF1099291B8_00 -0000100000000000 42B0000000000000_00 -FFFFFEFFFFE0007F C2700001FFF81000_00 -FFFFFFFFFFFFCFBE C0C8210000000000_00 -0000200000000000 42C0000000000000_00 -0000000901FFFFFD 422203FFFFFA0000_00 -FEC01FECA24DE1B0 C373FE0135DB21E5_00 -0000400000000000 42D0000000000000_00 -F7FFFFFFDFFF7FFF C3A0000000400100_01 -F858A66761669936 C39E9D66627A659B_01 -0000800000000000 42E0000000000000_00 -FFFEFF800000003E C2F007FFFFFFFC20_00 -F716EA43FAC45C97 C3A1D22B780A7747_01 -0001000000000000 42F0000000000000_00 -FFFFFFFFFFFFFFC6 C04D000000000000_00 -0024D70EC7661FD8 43426B8763B30FEC_00 -0002000000000000 4300000000000000_00 -C07FFFFFFFFFFFFE C3CFC00000000000_01 -FFD956DBD0AEE817 C343549217A88BF4_01 -0004000000000000 4310000000000000_00 -020003EFFFFFFFFE 4380001F80000000_01 -FFFFFFFFFFFF4300 C0E7A00000000000_00 -0008000000000000 4320000000000000_00 -4000000004002000 43D0000000010008_00 -C12EDF40F41F6021 C3CF68905F85F050_01 -0010000000000000 4330000000000000_00 -FF9000000000001D C35BFFFFFFFFFFF9_01 -FFFFFFF83DE950F6 C21F085ABC280000_00 -0020000000000000 4340000000000000_00 -800003FFFFFC0000 C3DFFFFF00000100_00 -FE2B59CB3A604D69 C37D4A634C59FB29_01 -0040000000000000 4350000000000000_00 -7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFF0_01 -000000A37C210862 42646F84210C4000_00 -0080000000000000 4360000000000000_00 -0002000002000002 4300000010000010_00 -FFFFB65CD8617789 C2D268C9E7A21DC0_00 -0100000000000000 4370000000000000_00 -00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 -FFFFFFFFFFFFF01D C0AFC60000000000_00 -0200000000000000 4380000000000000_00 -1000008000003FFF 43B0000080000040_01 -000000000D098D19 41AA131A32000000_00 -0400000000000000 4390000000000000_00 -03FFFFFFFFFFF5FF 438FFFFFFFFFFFB0_01 -000006B3BD2C7BEF 429ACEF4B1EFBC00_00 -0800000000000000 43A0000000000000_00 -00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 -FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 -1000000000000000 43B0000000000000_00 -001FFFC000000FFD 433FFFC000000FFD_00 -FFFFFFFFFFFFFF21 C06BE00000000000_00 -2000000000000000 43C0000000000000_00 -0000000041DFFFFF 41D077FFFFC00000_00 -FFFFFFFFFC648262 C18CDBECF0000000_00 -4000000000000000 43D0000000000000_00 -C0001FFFFFFFFFFB C3CFFFF000000000_01 -FFFFFF7353AC45D2 C261958A7745C000_00 -8000000000000000 C3E0000000000000_00 -FFFFFFFFFFE7EFFF C138100100000000_00 -0000000000A1202D 41642405A0000000_00 -C000000000000000 C3D0000000000000_00 -FFFFFFFFFFFF5F7F C0E4102000000000_00 -000000000040CA70 4150329C00000000_00 -E000000000000000 C3C0000000000000_00 -0000200201FFFFFE 42C00100FFFFFF00_00 -00000003B55D87D4 420DAAEC3EA00000_00 -F000000000000000 C3B0000000000000_00 -FF80000DFFFFFFFF C35FFFFC80000000_01 -000000010510FAEF 41F0510FAEF00000_00 -F800000000000000 C3A0000000000000_00 -0003FFF00000000F 430FFF8000000078_00 -000000000000724A 40DC928000000000_00 -FC00000000000000 C390000000000000_00 -FFFFFFDF80000002 C2403FFFFFFF0000_00 -0000000000000064 4059000000000000_00 -FE00000000000000 C380000000000000_00 -FEFFFFFFFFF800FE C370000000007FF0_01 -FFFFFFC2C6222702 C24E9CEEEC7F0000_00 -FF00000000000000 C370000000000000_00 -0000000408000002 4210200000080000_00 -000000E96DF1CB41 426D2DBE39682000_00 -FF80000000000000 C360000000000000_00 -007FFFFFFFFFF9FE 435FFFFFFFFFFE80_01 -F727F174DEE7DC85 C3A1B01D16423047_01 -FFC0000000000000 C350000000000000_00 -8000000003FFFEFE C3DFFFFFFFFF0000_01 -FFFFFFFFFFF0BD5B C12E854A00000000_00 -FFE0000000000000 C340000000000000_00 -0BEFFFFFFFFFFFFF 43A7E00000000000_01 -000000000002790C 4103C86000000000_00 -FFF0000000000000 C330000000000000_00 -FFFFFFFFFFEFFBFA C130040600000000_00 -000000169E75DF01 42369E75DF010000_00 -FFF8000000000000 C320000000000000_00 -00000007FEFFDFFF 421FFBFF7FFC0000_00 -000000000000000E 402C000000000000_00 -FFFC000000000000 C310000000000000_00 -0003FFFE0007FFFE 430FFFF0003FFFF0_00 -FFFFFFFFFFF28622 C12AF3BC00000000_00 -FFFE000000000000 C300000000000000_00 -FFFFFF7FFFFDF7FF C260000041002000_00 -00072F0EC496FE21 431CBC3B125BF884_00 -FFFF000000000000 C2F0000000000000_00 -DFBFFFFFFFFFFFFE C3C0200000000000_01 -0000000000FC1FCA 416F83F940000000_00 -FFFF800000000000 C2E0000000000000_00 -00000FFF800FFFFE 42AFFF001FFFFC00_00 -FFFF5194E4A9C2CE C2E5CD636AC7A640_00 -FFFFC00000000000 C2D0000000000000_00 -00000002100007FD 420080003FE80000_00 -FFFFFFFFFFC2D8FE C14E938100000000_00 -FFFFE00000000000 C2C0000000000000_00 -000000000007FF6E 411FFDB800000000_00 -000000000001766E 40F766E000000000_00 -FFFFF00000000000 C2B0000000000000_00 -0040000400000002 4350000100000000_01 -0000000000007841 40DE104000000000_00 -FFFFF80000000000 C2A0000000000000_00 -3DFFFFFFFFFFFF7E 43CF000000000000_01 -FFFFFFE549E17E30 C23AB61E81D00000_00 -FFFFFC0000000000 C290000000000000_00 -FFFFFFFFFFFFFEE1 C071F00000000000_00 -FFFFFFFFFFFFFFE7 C039000000000000_00 -FFFFFE0000000000 C280000000000000_00 -000000000EFFFFDF 41ADFFFFBE000000_00 -FFFFFFFFFFFFFF73 C061A00000000000_00 -FFFFFF0000000000 C270000000000000_00 -FD00000008000000 C387FFFFFFC00000_00 -000000000001DBB1 40FDBB1000000000_00 -FFFFFF8000000000 C260000000000000_00 -FFFFFFFFFFF8007F C11FFE0400000000_00 -FFFFFFFEFD10A515 C1F02EF5AEB00000_00 -FFFFFFC000000000 C250000000000000_00 -FFEFFFFFFFFFFFFE C330000000000002_00 -FAB02984F6283B6C C3953F59EC275F12_01 -FFFFFFE000000000 C240000000000000_00 -FFFFFFBC000001FE C250FFFFFF808000_00 -FEB087C6B9FE7FE0 C374F78394601802_00 -FFFFFFF000000000 C230000000000000_00 -FFF80001000007FE C31FFFFBFFFFE008_00 -00F2762EA6837956 436E4EC5D4D06F2B_01 -FFFFFFF800000000 C220000000000000_00 -FFF7E0FFFFFFFFFE C3203E0000000004_00 -00002E1175484626 42C708BAA4231300_00 -FFFFFFFC00000000 C210000000000000_00 -0000200020000FFE 42C000100007FF00_00 -000000000000068F 409A3C0000000000_00 -FFFFFFFE00000000 C200000000000000_00 -021FFFFFFFFBFFFF 4380FFFFFFFFE000_01 -FFFFFFFFFFFFFFF9 C01C000000000000_00 -FFFFFFFF00000000 C1F0000000000000_00 -FFFFFFD0000FFFFD C247FFF800018000_00 -000000BDF6658B83 4267BECCB1706000_00 -FFFFFFFF80000000 C1E0000000000000_00 -1000001FFDFFFFFF 43B000001FFE0000_01 -0000000000003B5B 40CDAD8000000000_00 -FFFFFFFFC0000000 C1D0000000000000_00 -FFFFFFBFFE0FFFFF C250007C00004000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -FFFFFFFFE0000000 C1C0000000000000_00 -FFFFFFFBF00007FF C2103FFFE0040000_00 -01E986274F48EAAD 437E986274F48EAB_01 -FFFFFFFFF0000000 C1B0000000000000_00 -1FFFFFFDFFFFFF7F 43BFFFFFFDFFFFFF_01 -FFFFFFFFFFFFCB5A C0CA530000000000_00 -FFFFFFFFF8000000 C1A0000000000000_00 -7FF000000000FFFF 43DFFC0000000040_01 -00000003C2717FC3 420E138BFE180000_00 -FFFFFFFFFC000000 C190000000000000_00 -FFFFFFE00008001F C23FFFF7FFE10000_00 -FFFFFFFFFFEFABDA C130542600000000_00 -FFFFFFFFFE000000 C180000000000000_00 -0200000000000002 4380000000000000_01 -FFFFFFFFF8FDA53F C19C096B04000000_00 -FFFFFFFFFF000000 C170000000000000_00 -F6000003FFFFFFFE C3A3FFFFF8000000_01 -FFFFFFFFFFFFFFD0 C048000000000000_00 -FFFFFFFFFF800000 C160000000000000_00 -FFFFFFFFFFBFFF7E C150002080000000_00 -00000000EE0FEA62 41EDC1FD4C400000_00 -FFFFFFFFFFC00000 C150000000000000_00 -0000007FFF9FFFFD 425FFFE7FFFF4000_00 -00000037F35EDC1D 424BF9AF6E0E8000_00 -FFFFFFFFFFE00000 C140000000000000_00 -FFFFFFF7FDFFFF7D C220040001060000_00 -00000000000001AD 407AD00000000000_00 -FFFFFFFFFFF00000 C130000000000000_00 -FFFFFF0000100020 C26FFFFDFFFC0000_00 -27F167FBC7FC5F9A 43C3F8B3FDE3FE30_01 -FFFFFFFFFFF80000 C120000000000000_00 -003FFFFFFFFC0001 434FFFFFFFFE0000_01 -000E48F9F4EBD30E 432C91F3E9D7A61C_00 -FFFFFFFFFFFC0000 C110000000000000_00 -DFFFFFFFFFFBFFFE C3C0000000000200_01 -FC91C23EE8C9424F C38B71EE08B9B5EE_01 -FFFFFFFFFFFE0000 C100000000000000_00 -F7DFFBFFFFFFFFFE C3A0400800000000_01 -000000002CAE080C 41C6570406000000_00 -FFFFFFFFFFFF0000 C0F0000000000000_00 -FFFFC00010000020 C2CFFFF7FFFFF000_00 -04D921F917B20E40 43936487E45EC839_00 -FFFFFFFFFFFF8000 C0E0000000000000_00 -F8000FFFFFFFFFFD C39FFFC000000000_01 -FFF17C566BC7D811 C32D075328704FDE_00 -FFFFFFFFFFFFC000 C0D0000000000000_00 -00000000000000FE 406FC00000000000_00 -FFF82AC14930D386 C31F54FADB3CB1E8_00 -FFFFFFFFFFFFE000 C0C0000000000000_00 -00000000000003FC 408FE00000000000_00 -000E62EC60E119FC 432CC5D8C1C233F8_00 -FFFFFFFFFFFFF000 C0B0000000000000_00 -FFFFEFF7FF7FFFFE C2B0080080000200_00 -0E2B1ECF210EEDC5 43AC563D9E421DDC_01 -FFFFFFFFFFFFF800 C0A0000000000000_00 -00000000007FFF1F 415FFFC7C0000000_00 -FFFFFE534F5676F7 C27ACB0A98909000_00 -FFFFFFFFFFFFFC00 C090000000000000_00 -0000001004FFFFFD 423004FFFFFD0000_00 -0000035C939669F1 428AE49CB34F8800_00 -FFFFFFFFFFFFFE00 C080000000000000_00 -1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFE_01 -FFFFFFFFFFFFFF91 C05BC00000000000_00 -FFFFFFFFFFFFFF00 C070000000000000_00 -01FFFFFFFBFFEFFE 437FFFFFFFBFFF00_01 -000000000000016E 4076E00000000000_00 -FFFFFFFFFFFFFF80 C060000000000000_00 -FFF7FFFFFFFFF7FD C320000000001006_00 -FFFFF8E2BCFAC553 C29C750C14EAB400_00 -FFFFFFFFFFFFFFC0 C050000000000000_00 -FFFFFBFFFFFE0FFE C290000007C00800_00 -00000001A4E704BF 41FA4E704BF00000_00 -FFFFFFFFFFFFFFE0 C040000000000000_00 -1400007FFFFFFFFD 43B4000080000000_01 -FFFFFFFC93B187B4 C20B6273C2600000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -40000000007FFFFD 43D0000000002000_01 -000000000067D468 4159F51A00000000_00 -FFFFFFFFFFFFFFF8 C020000000000000_00 -007FFEFFFFFBFFFE 435FFFBFFFFF0000_01 -FFFFFFE26CEC79F8 C23D931386080000_00 -FFFFFFFFFFFFFFFC C010000000000000_00 -00FFFFFF000000FF 436FFFFFE0000020_01 -FFFFFFFFE0D3983A C1BF2C67C6000000_00 -FFFFFFFFFFFFFFFE C000000000000000_00 -00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 -FFFFFFFDF4A7088A C2005AC7BBB00000_00 -FFFFFFFFFFFFFFFF BFF0000000000000_00 -000008000000027E 42A000000004FC00_00 -000000000000F4E8 40EE9D0000000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFF83FFDF C15F000840000000_00 -00000E11407887B2 42AC2280F10F6400_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -04000003FFFFFFF6 4390000010000000_01 -0000000000000513 40944C0000000000_00 -FFFFFFFFFFFFFFF7 C022000000000000_00 -BFFC00000000003E C3D0010000000000_01 -00000008D7BBB75B 4221AF776EB60000_00 -FFFFFFFFFFFFFFEF C031000000000000_00 -000FFFFBFFFC0000 432FFFF7FFF80000_00 -FFFFFFFFFFCD5A23 C14952EE80000000_00 -FFFFFFFFFFFFFFDF C040800000000000_00 -FFBFDFFFBFFFFFFF C350080010000000_01 -000000000000007F 405FC00000000000_00 -FFFFFFFFFFFFFFBF C050400000000000_00 -00000007FF800003 421FFE00000C0000_00 -000000000002BB02 4105D81000000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEE7FF C0F1801000000000_00 -00264B2B9BAD0DA2 43432595CDD686D1_00 -FFFFFFFFFFFFFEFF C070100000000000_00 -0000000000100803 4130080300000000_00 -FF9B1DCB9F857D5E C359388D181EA0A8_01 -FFFFFFFFFFFFFDFF C080080000000000_00 -FFFFFFBFFFFFEFEE C250000004048000_00 -F6FD7542899C1C6F C3A205157AECC7C7_01 -FFFFFFFFFFFFFBFF C090040000000000_00 -FF800000004001FF C35FFFFFFFEFFF80_01 -0000000002BE4932 4185F24990000000_00 -FFFFFFFFFFFFF7FF C0A0020000000000_00 -00001004000FFFFE 42B004000FFFFE00_00 -FFFFFF9DAA0123E0 C258957FB7080000_00 -FFFFFFFFFFFFEFFF C0B0010000000000_00 -00000001FDFFFDFE 41FFDFFFDFE00000_00 -FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 -FFFFFFFFFFFFDFFF C0C0008000000000_00 -FE0FE00000000000 C37F020000000000_00 -0779ED944A4E2779 439DE7B65129389E_01 -FFFFFFFFFFFFBFFF C0D0004000000000_00 -FBFFFE0400000000 C3900007F0000000_00 -0000010127E03666 4270127E03666000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -FFFFF0200000FFFE C2AFBFFFFE000400_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEFFFF C0F0001000000000_00 -FFEFFE0000080000 C33001FFFFF80000_00 -FFFFFFFFFD3354EA C1866558B0000000_00 -FFFFFFFFFFFDFFFF C100000800000000_00 -003FF0000003FFFE 434FF8000001FFFF_00 -0000006375B23F7B 4258DD6C8FDEC000_00 -FFFFFFFFFFFBFFFF C110000400000000_00 -000407FFFFFFFFF6 43101FFFFFFFFFD8_00 -0000000092117F38 41E2422FE7000000_00 -FFFFFFFFFFF7FFFF C120000200000000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -00000000000008BE 40A17C0000000000_00 -FFFFFFFFFFEFFFFF C130000100000000_00 -004000020FFFFFFF 4350000084000000_01 -FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 -FFFFFFFFFFDFFFFF C140000080000000_00 -00FFFFFFFFFFFFFD 4370000000000000_01 -00000023C2C6F284 4241E16379420000_00 -FFFFFFFFFFBFFFFF C150000040000000_00 -FFFDDFFFFFFFFFFD C301000000000018_00 -00000000746356C4 41DD18D5B1000000_00 -FFFFFFFFFF7FFFFF C160000020000000_00 -010000000000BFFF 4370000000000C00_01 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFEFFFFFF C170000010000000_00 -FFFFBF7FFBFFFFFE C2D0200100000080_00 -00000006386CE889 4218E1B3A2240000_00 -FFFFFFFFFDFFFFFF C180000008000000_00 -F00000F7FFFFFFFF C3AFFFFE10000000_01 -FFFDFC53090C46A4 C3001D67B79DCAE0_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -0000000000800047 41600008E0000000_00 -FFFFFFFFD693872E C1C4B63C69000000_00 -FFFFFFFFF7FFFFFF C1A0000002000000_00 -000000007FBFFBFF 41DFEFFEFFC00000_00 -00000026A7845E35 424353C22F1A8000_00 -FFFFFFFFEFFFFFFF C1B0000001000000_00 -FFFFFFDFFFFFFBFD C240000002018000_00 -000000001433D14C 41B433D14C000000_00 -FFFFFFFFDFFFFFFF C1C0000000800000_00 -0001FFFFFFE0000E 42FFFFFFFE0000E0_00 -F0F23E8068D3D84A C3AE1B82FF2E584F_01 -FFFFFFFFBFFFFFFF C1D0000000400000_00 -F7FFBFFFFFFFBFFF C3A0008000000080_01 -FFFFBD29B7459087 C2D0B5922E9BDE40_00 -FFFFFFFF7FFFFFFF C1E0000000200000_00 -FFFFFFF8FFFFBFFF C21C000100040000_00 -FFFFFFFFFFEDDC06 C13223FA00000000_00 -FFFFFFFEFFFFFFFF C1F0000000100000_00 -FFFFFFF80001FFFF C21FFFF800040000_00 -0000000000002FF9 40C7FC8000000000_00 -FFFFFFFDFFFFFFFF C200000000080000_00 -004000040000FFFF 4350000100004000_01 -FFFFFFFFFFFFFFF1 C02E000000000000_00 -FFFFFFFBFFFFFFFF C210000000040000_00 -C0000000007FFFFA C3CFFFFFFFFFC000_01 -FFFFFFFFFE053E2B C17FAC1D50000000_00 -FFFFFFF7FFFFFFFF C220000000020000_00 -7FFE000007FFFFFF 43DFFF8000020000_01 -000000000000000D 402A000000000000_00 -FFFFFFEFFFFFFFFF C230000000010000_00 -F80000000001007E C39FFFFFFFFFFBFE_01 -FFFFED48424AD9D6 C2B2B7BDB5262A00_00 -FFFFFFDFFFFFFFFF C240000000008000_00 -FFFFFE0001FEFFFF C27FFFE010001000_00 -000000000000013B 4073B00000000000_00 -FFFFFFBFFFFFFFFF C250000000004000_00 -0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 -4A16BD4128090C83 43D285AF504A0243_01 -FFFFFF7FFFFFFFFF C260000000002000_00 -00FFF7FFFF7FFFFE 436FFEFFFFF00000_01 -0000000000000006 4018000000000000_00 -FFFFFEFFFFFFFFFF C270000000001000_00 -FBFFFFBFFFBFFFFF C390000100010000_01 -00000000000001BA 407BA00000000000_00 -FFFFFDFFFFFFFFFF C280000000000800_00 -0000000040000082 41D0000020800000_00 -FF07A2BF5B689F89 C36F0BA81492EC0F_01 -FFFFFBFFFFFFFFFF C290000000000400_00 -0000001FF8000008 423FF80000080000_00 -F87CAA7DE672DE8B C39E0D5608663486_01 -FFFFF7FFFFFFFFFF C2A0000000000200_00 -07FFF80000000002 439FFFE000000000_01 -0000000010A1E5B8 41B0A1E5B8000000_00 -FFFFEFFFFFFFFFFF C2B0000000000100_00 -F7FFFFE00007FFFF C3A000003FFFF000_01 -FFFFFFFFFFF6ADFC C122A40800000000_00 -FFFFDFFFFFFFFFFF C2C0000000000080_00 -FFFFFF03FFFFFFC0 C26F800000080000_00 -EA579475948F0032 C3B5A86B8A6B7100_01 -FFFFBFFFFFFFFFFF C2D0000000000040_00 -FC00000000003FF6 C38FFFFFFFFFFE00_01 -002E677AC313BF60 434733BD6189DFB0_00 -FFFF7FFFFFFFFFFF C2E0000000000020_00 -02000007FF7FFFFF 438000003FFC0000_01 -0000000E999639F1 422D332C73E20000_00 -FFFEFFFFFFFFFFFF C2F0000000000010_00 -FFFF83FFFFFFFFBE C2DF000000001080_00 -000000000001537D 40F537D000000000_00 -FFFDFFFFFFFFFFFF C300000000000008_00 -EFFFFFC00000003D C3B0000040000000_01 -FFFFFFF21FEDFD35 C22BC02405960000_00 -FFFBFFFFFFFFFFFF C310000000000004_00 -FFFFFFF0000007FE C22FFFFFF0040000_00 -FFFFFFFFFFDE0839 C140FBE380000000_00 -FFF7FFFFFFFFFFFF C320000000000002_00 -0000007FFFE000FF 425FFFF8003FC000_00 -FFFFFFFF79F30F48 C1E0C19E17000000_00 -FFEFFFFFFFFFFFFF C330000000000001_00 -FFFFFC13FFFFFFFD C28F600000001800_00 -0000000000001B85 40BB850000000000_00 -FFDFFFFFFFFFFFFF C340000000000000_01 -000008000007FFFE 42A000000FFFFC00_00 -12DB4409E5AE87E6 43B2DB4409E5AE88_01 -FFBFFFFFFFFFFFFF C350000000000000_01 -FFFFFFFFFFF7BFEE C120802400000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FF7FFFFFFFFFFFFF C360000000000000_01 -000000001040FFFE 41B040FFFE000000_00 -00000909A09C13D3 42A213413827A600_00 -FEFFFFFFFFFFFFFF C370000000000000_01 -FFFFFF01FFFFFF7F C26FC00000102000_00 -FFFFFF72E7D2575D C261A305B5146000_00 -FDFFFFFFFFFFFFFF C380000000000000_01 -FFFFFFFFFFFEFFDB C0F0025000000000_00 -0000000000000017 4037000000000000_00 -FBFFFFFFFFFFFFFF C390000000000000_01 -100000001FFFFFF6 43B0000000200000_01 -000000114B12EF51 42314B12EF510000_00 -F7FFFFFFFFFFFFFF C3A0000000000000_01 -0407FFFFFFFFFEFF 43901FFFFFFFFFFC_01 -FFFFFF769F3A5C2C C2612C18B47A8000_00 -EFFFFFFFFFFFFFFF C3B0000000000000_01 -FFFFFFFDF7FFFFFD C200400000180000_00 -FFFFFFFFFFFFFFF2 C02C000000000000_00 -DFFFFFFFFFFFFFFF C3C0000000000000_01 -FFFFFFFFFE0007FF C17FFF8010000000_00 -000000000000001E 403E000000000000_00 -BFFFFFFFFFFFFFFF C3D0000000000000_01 -FFF800000009FFFF C31FFFFFFFD80004_00 -0000000000007AA4 40DEA90000000000_00 -7FFFFFFFFFFFFFFF 43E0000000000000_01 -4080000000FFFFFF 43D0200000004000_01 -000000000DE7601D 41ABCEC03A000000_00 -3FFFFFFFFFFFFFFF 43D0000000000000_01 -FFCFFFFFFFBFFFFE C348000000200001_00 -FFFFFFFFFFFFFFCA C04B000000000000_00 -1FFFFFFFFFFFFFFF 43C0000000000000_01 -000080400000003F 42E00800000007E0_00 -00000000001F75A5 413F75A500000000_00 -0FFFFFFFFFFFFFFF 43B0000000000000_01 -FFFFFFEFFFFFCFFE C230000030020000_00 -FFFFFEE775887420 C27188A778BE0000_00 -07FFFFFFFFFFFFFF 43A0000000000000_01 -00000000000801FE 412003FC00000000_00 -0000000000213FF1 41409FF880000000_00 -03FFFFFFFFFFFFFF 4390000000000000_01 -07FEFFFFFFFFFFEE 439FFC0000000000_01 -0000000000000004 4010000000000000_00 -01FFFFFFFFFFFFFF 4380000000000000_01 -0000000820000003 4220400000060000_00 -FFFFFFF9AD105214 C2194BBEB7B00000_00 -00FFFFFFFFFFFFFF 4370000000000000_01 -FFFFF00FFFFFFFBE C2AFE00000008400_00 -FFFFFFFFFFCC48E7 C149DB8C80000000_00 -007FFFFFFFFFFFFF 4360000000000000_01 -00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 -FFFFFFFFFF0BA6CB C16E8B26A0000000_00 -003FFFFFFFFFFFFF 4350000000000000_01 -FFFFFF7FBFFFFFBF C260080000082000_00 -FFFFFFFFFFF24425 C12B77B600000000_00 -001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 -200000001FFBFFFF 43C00000000FFE00_01 -FFFFFF4E7115EC53 C26631DD4275A000_00 -000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 -FFFFF803FFFFFFBF C29FF00000010400_00 -FFFFFC2E539ADCFE C28E8D6329181000_00 -0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -00000055084732F3 42554211CCBCC000_00 -0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 -BFFF7FFFFFFFFE00 C3D0002000000000_01 -FFFFFFFFFFFF8543 C0DEAF4000000000_00 -0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 -0000001FFBFFE000 423FFBFFE0000000_00 -FFFFFFFFFFFE491B C0FB6E5000000000_00 -0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 -FC00200000001FFE C38FFEFFFFFFFF00_01 -FFFFF16898822A24 C2AD2ECEFBABB800_00 -00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 -3FFF03FFFFFFFFFE 43CFFF8200000000_01 -FFFFFF8FFE18C7BF C25C0079CE104000_00 -00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 -FFFFFEFFFEFFFFFD C270001000003000_00 -00F03620C1266ED9 436E06C41824CDDB_01 -00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 -BF7EFFFFFFFFFFFF C3D0204000000000_01 -FFFFFFFFFFFFFFD5 C045800000000000_00 -00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 -FFFBFFFFF803FFFE C31000001FF00008_00 -0000000000068684 411A1A1000000000_00 -000007FFFFFFFFFF 429FFFFFFFFFFC00_00 -DFFFFFE00000001E C3C0000010000000_01 -FFFFFFFFFFFFECF5 C0B30B0000000000_00 -000003FFFFFFFFFF 428FFFFFFFFFF800_00 -FFFF00400000FFFF C2EFF7FFFFE00020_00 -0000000000000002 4000000000000000_00 -000001FFFFFFFFFF 427FFFFFFFFFF000_00 -FBFFFFFFFFFFBDFE C390000000000108_01 -0000000000000BC9 40A7920000000000_00 -000000FFFFFFFFFF 426FFFFFFFFFE000_00 -807FFFFFFFFFDFFE C3DFE00000000008_01 -FFC274E35A70CD76 C34EC58E52C79945_00 -0000007FFFFFFFFF 425FFFFFFFFFC000_00 -0FFFFFFFFEFFFFFD 43AFFFFFFFFE0000_01 -FFFFFFFF00E73AFC C1EFE318A0800000_00 -0000003FFFFFFFFF 424FFFFFFFFF8000_00 -FFC000000001000E C34FFFFFFFFF7FF9_00 -FFFFFFFFFFFE15E9 C0FEA17000000000_00 -0000001FFFFFFFFF 423FFFFFFFFF0000_00 -0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 -0000000000000033 4049800000000000_00 -0000000FFFFFFFFF 422FFFFFFFFE0000_00 -000000001FFFBFFF 41BFFFBFFF000000_00 -FFFFFFEE6B141E1B C23194EBE1E50000_00 -00000007FFFFFFFF 421FFFFFFFFC0000_00 -FFFFFFFFF60007FF C1A3FFF002000000_00 -00000001AB310BA6 41FAB310BA600000_00 -00000003FFFFFFFF 420FFFFFFFF80000_00 -0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 -FFFFFFFFFFFFF195 C0ACD60000000000_00 -00000001FFFFFFFF 41FFFFFFFFF00000_00 -FFFFFFFF8000000B C1DFFFFFFD400000_00 -00000019BA8D5559 4239BA8D55590000_00 -00000000FFFFFFFF 41EFFFFFFFE00000_00 -FBFEFFFFFFFFFFF9 C390040000000000_01 -FFFFFFB6F062822D C25243E75F74C000_00 -000000007FFFFFFF 41DFFFFFFFC00000_00 -0001000000000082 42F0000000000820_00 -01CEAD9E2FB104A4 437CEAD9E2FB104A_01 -000000003FFFFFFF 41CFFFFFFF800000_00 -000003FFFFFFFF7C 428FFFFFFFFBE000_00 -FFFFFFFFFD681E78 C184BF0C40000000_00 -000000001FFFFFFF 41BFFFFFFF000000_00 -00002000400001FF 42C000200000FF80_00 -0000000000000018 4038000000000000_00 -000000000FFFFFFF 41AFFFFFFE000000_00 -3FFF80000000003E 43CFFFC000000000_01 -FFFFFFFFFFFFFF95 C05AC00000000000_00 -0000000007FFFFFF 419FFFFFFC000000_00 -010000BFFFFFFFFF 4370000C00000000_01 -0000001697087B19 423697087B190000_00 -0000000003FFFFFF 418FFFFFF8000000_00 -FBFFFFFFFFEEFFFD C390000000004400_01 -0000000E64BDFC55 422CC97BF8AA0000_00 -0000000001FFFFFF 417FFFFFF0000000_00 -FC00000001FFFFFE C38FFFFFFFF00000_01 -FFFED156A62AB849 C2F2EA959D547B70_00 -0000000000FFFFFF 416FFFFFE0000000_00 -FFFFFFF83FEFFFFD C21F0040000C0000_00 -00015354EAE7C259 42F5354EAE7C2590_00 -00000000007FFFFF 415FFFFFC0000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFF0F4DF3C75 C22E164187160000_00 -00000000003FFFFF 414FFFFF80000000_00 -FFFA000000001FFF C317FFFFFFFF8004_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000001FFFFF 413FFFFF00000000_00 -FFFFFFFFFF7FFE40 C160003800000000_00 -FFFFFFDB5433CB9B C24255E61A328000_00 -00000000000FFFFF 412FFFFE00000000_00 -FFFFFDFFDFFDFFFD C280010010001800_00 -FFFFFFFFFFDEAE1F C140A8F080000000_00 -000000000007FFFF 411FFFFC00000000_00 -FFFFFFFFF0080006 C1AFEFFFF4000000_00 -FFFFFFFE7735DEC7 C1F88CA213900000_00 -000000000003FFFF 410FFFF800000000_00 -00000001FBFFFFFF 41FFBFFFFFF00000_00 -000003757D8B12ED 428BABEC58976800_00 -000000000001FFFF 40FFFFF000000000_00 -FFFFFE07F7FFFFFF C27F808000001000_00 -00000A654064E046 42A4CA80C9C08C00_00 -000000000000FFFF 40EFFFE000000000_00 -08000000000017FF 43A0000000000030_01 -FFFFFFFFFFFFFFE7 C039000000000000_00 -0000000000007FFF 40DFFFC000000000_00 -07FFFFFFFFFFFDF6 439FFFFFFFFFFFF8_01 -FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 -0000000000003FFF 40CFFF8000000000_00 -0000300004000000 42C8000200000000_00 -FFFFFFF70B77F34F C221E91019620000_00 -0000000000001FFF 40BFFF0000000000_00 -FFFFFF80006FFFFE C25FFFE400008000_00 -0000013EB4D67EC8 4273EB4D67EC8000_00 -0000000000000FFF 40AFFE0000000000_00 -BFFFDFFFFBFFFFFF C3D0000800010000_01 -0005CEAF34EA1DC7 43173ABCD3A8771C_00 -00000000000007FF 409FFC0000000000_00 -00004800007FFFFD 42D200001FFFFF40_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000000003FF 408FF80000000000_00 -0000000200001000 4200000080000000_00 -00000000000360D0 410B068000000000_00 -00000000000001FF 407FF00000000000_00 -01003FFFFFFFFFFC 4370040000000000_01 -00C000708FF1BA51 4368000E11FE374A_01 -00000000000000FF 406FE00000000000_00 -F802000003FFFFFF C39FF7FFFFF00000_01 -0F9E07DCC0BDC061 43AF3C0FB9817B81_01 -000000000000007F 405FC00000000000_00 -03FF0000000000FF 438FF80000000008_01 -FFFFFFE1B9B2A079 C23E464D5F870000_00 -000000000000003F 404F800000000000_00 -FFF80000000080FF C31FFFFFFFFDFC04_00 -00000000001EB5B4 413EB5B400000000_00 -000000000000001F 403F000000000000_00 -000000000077FBFE 415DFEFF80000000_00 -00000000005AC607 4156B181C0000000_00 -000000000000000F 402E000000000000_00 -FFFFFFFEF80000FF C1F07FFFF0100000_00 -000005C5B9D66984 429716E759A61000_00 -0000000000000007 401C000000000000_00 -C001FFFFFFF00000 C3CFFF0000000800_00 -00001D06B372AA06 42BD06B372AA0600_00 -0000000000000003 4008000000000000_00 +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFE_01 +0000000032CC8B7A_41C96645BD000000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_C1CFFFE001000000_00 +032C857F319EDE38_4389642BF98CF6F2_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_C29000001FFF0800_00 +00394C79B6D3007B_434CA63CDB69803E_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_C39000003FFFFFF8_01 +0000000001AE458D_417AE458D0000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +F9EB456140D88764_C39852EA7AFC9DE2_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_C2BBFF0000000200_00 +07DE834A248EDF36_439F7A0D28923B7D_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +FFFFFFFFFFE385E2_C13C7A1E00000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_C3AFF7C000000000_01 +000000059EB1FD45_42167AC7F5140000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_C108003800000000_00 +FFFFFFFFFFFEDDFE_C0F2202000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000000C89FF56B_41E913FEAD600000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0_43BB5E4F0BE0DEC0_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_C3003FE000000008_00 +FFFFFFFFFFF4766B_C127132A00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000000C_4028000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +FFE662A109109D0A_C3399D5EF6EF62F6_00 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_C3CFFFFFFFE40000_01 +FFFFFFFFFFFFFFE4_C03C000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_C39FFBFFFFFFC000_00 +FE114B79075F70EE_C37EEB486F8A08F1_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000100_01 +00000000000003AC_408D600000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +00000044A3A3DBE5_425128E8F6F94000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_C33FFFC100000001_00 +FFFFFFFFFFFF1A91_C0ECADE000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_C2A0780000000600_00 +0000000000003309_40C9848000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58_C065000000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_C240FF0000010000_00 +0000000000002980_40C4C00000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +000000000000005D_4057400000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8_C30B9EE12E98A940_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_C3BFFFFFFFFFC000_01 +FFFFFDE3C1DEC43C_C280E1F109DE2000_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_C2EFFFFE80000060_00 +000000000030FFBE_41487FDF00000000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_C2FFFFFF80010030_00 +FFFFFFFFEFDEED86_C1B021127A000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_C3A8000000008000_01 +000000001DA3FF45_41BDA3FF45000000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54_C1F64E434AC00000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +F27DD19DE6563714_C3AB045CC4335392_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_C34FFFFFFFDFFC01_00 +000000000001A359_40FA359000000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +FFFFFFFFFE62EC20_C179D13E00000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000285F_40C42F8000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_C1D00003FC400000_00 +FFFFF836F99DBAA8_C29F241989156000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0033466832042D47_4349A334190216A4_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_C09DE40000000000_00 +00000000003829C8_414C14E400000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000000FB77C672B_422F6EF8CE560000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFC000000_01 +0000000000001B78_40BB780000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_C360000000020400_01 +0000000000000071_405C400000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86_C05E800000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +FFF8A60D9E19F17E_C31D67C987983A08_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +FFFFFFFFF7506DBA_C1A15F248C000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_C0F0409000000000_00 +FFFFFFFFFEA42AC9_C175BD5370000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89_C33855C0D4253377_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9_C3004BF1099291B8_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_C2700001FFF81000_00 +FFFFFFFFFFFFCFBE_C0C8210000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +FEC01FECA24DE1B0_C373FE0135DB21E5_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_C3A0000000400100_01 +F858A66761669936_C39E9D66627A659B_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_C2F007FFFFFFFC20_00 +F716EA43FAC45C97_C3A1D22B780A7747_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_C04D000000000000_00 +0024D70EC7661FD8_43426B8763B30FEC_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_C3CFC00000000000_01 +FFD956DBD0AEE817_C343549217A88BF4_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F80000000_01 +FFFFFFFFFFFF4300_C0E7A00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +C12EDF40F41F6021_C3CF68905F85F050_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_C35BFFFFFFFFFFF9_01 +FFFFFFF83DE950F6_C21F085ABC280000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_C3DFFFFF00000100_00 +FE2B59CB3A604D69_C37D4A634C59FB29_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFF0_01 +000000A37C210862_42646F84210C4000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +FFFFB65CD8617789_C2D268C9E7A21DC0_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D_C0AFC60000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B0000080000040_01 +000000000D098D19_41AA131A32000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFB0_01 +000006B3BD2C7BEF_429ACEF4B1EFBC00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8_C2E634A444AB6B00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +FFFFFFFFFFFFFF21_C06BE00000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +FFFFFFFFFC648262_C18CDBECF0000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_C3CFFFF000000000_01 +FFFFFF7353AC45D2_C261958A7745C000_00 +8000000000000000_C3E0000000000000_00 +FFFFFFFFFFE7EFFF_C138100100000000_00 +0000000000A1202D_41642405A0000000_00 +C000000000000000_C3D0000000000000_00 +FFFFFFFFFFFF5F7F_C0E4102000000000_00 +000000000040CA70_4150329C00000000_00 +E000000000000000_C3C0000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000003B55D87D4_420DAAEC3EA00000_00 +F000000000000000_C3B0000000000000_00 +FF80000DFFFFFFFF_C35FFFFC80000000_01 +000000010510FAEF_41F0510FAEF00000_00 +F800000000000000_C3A0000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000000724A_40DC928000000000_00 +FC00000000000000_C390000000000000_00 +FFFFFFDF80000002_C2403FFFFFFF0000_00 +0000000000000064_4059000000000000_00 +FE00000000000000_C380000000000000_00 +FEFFFFFFFFF800FE_C370000000007FF0_01 +FFFFFFC2C6222702_C24E9CEEEC7F0000_00 +FF00000000000000_C370000000000000_00 +0000000408000002_4210200000080000_00 +000000E96DF1CB41_426D2DBE39682000_00 +FF80000000000000_C360000000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE80_01 +F727F174DEE7DC85_C3A1B01D16423047_01 +FFC0000000000000_C350000000000000_00 +8000000003FFFEFE_C3DFFFFFFFFF0000_01 +FFFFFFFFFFF0BD5B_C12E854A00000000_00 +FFE0000000000000_C340000000000000_00 +0BEFFFFFFFFFFFFF_43A7E00000000000_01 +000000000002790C_4103C86000000000_00 +FFF0000000000000_C330000000000000_00 +FFFFFFFFFFEFFBFA_C130040600000000_00 +000000169E75DF01_42369E75DF010000_00 +FFF8000000000000_C320000000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000000E_402C000000000000_00 +FFFC000000000000_C310000000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +FFFFFFFFFFF28622_C12AF3BC00000000_00 +FFFE000000000000_C300000000000000_00 +FFFFFF7FFFFDF7FF_C260000041002000_00 +00072F0EC496FE21_431CBC3B125BF884_00 +FFFF000000000000_C2F0000000000000_00 +DFBFFFFFFFFFFFFE_C3C0200000000000_01 +0000000000FC1FCA_416F83F940000000_00 +FFFF800000000000_C2E0000000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE_C2E5CD636AC7A640_00 +FFFFC00000000000_C2D0000000000000_00 +00000002100007FD_420080003FE80000_00 +FFFFFFFFFFC2D8FE_C14E938100000000_00 +FFFFE00000000000_C2C0000000000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000001766E_40F766E000000000_00 +FFFFF00000000000_C2B0000000000000_00 +0040000400000002_4350000100000000_01 +0000000000007841_40DE104000000000_00 +FFFFF80000000000_C2A0000000000000_00 +3DFFFFFFFFFFFF7E_43CF000000000000_01 +FFFFFFE549E17E30_C23AB61E81D00000_00 +FFFFFC0000000000_C290000000000000_00 +FFFFFFFFFFFFFEE1_C071F00000000000_00 +FFFFFFFFFFFFFFE7_C039000000000000_00 +FFFFFE0000000000_C280000000000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73_C061A00000000000_00 +FFFFFF0000000000_C270000000000000_00 +FD00000008000000_C387FFFFFFC00000_00 +000000000001DBB1_40FDBB1000000000_00 +FFFFFF8000000000_C260000000000000_00 +FFFFFFFFFFF8007F_C11FFE0400000000_00 +FFFFFFFEFD10A515_C1F02EF5AEB00000_00 +FFFFFFC000000000_C250000000000000_00 +FFEFFFFFFFFFFFFE_C330000000000002_00 +FAB02984F6283B6C_C3953F59EC275F12_01 +FFFFFFE000000000_C240000000000000_00 +FFFFFFBC000001FE_C250FFFFFF808000_00 +FEB087C6B9FE7FE0_C374F78394601802_00 +FFFFFFF000000000_C230000000000000_00 +FFF80001000007FE_C31FFFFBFFFFE008_00 +00F2762EA6837956_436E4EC5D4D06F2B_01 +FFFFFFF800000000_C220000000000000_00 +FFF7E0FFFFFFFFFE_C3203E0000000004_00 +00002E1175484626_42C708BAA4231300_00 +FFFFFFFC00000000_C210000000000000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000068F_409A3C0000000000_00 +FFFFFFFE00000000_C200000000000000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFE000_01 +FFFFFFFFFFFFFFF9_C01C000000000000_00 +FFFFFFFF00000000_C1F0000000000000_00 +FFFFFFD0000FFFFD_C247FFF800018000_00 +000000BDF6658B83_4267BECCB1706000_00 +FFFFFFFF80000000_C1E0000000000000_00 +1000001FFDFFFFFF_43B000001FFE0000_01 +0000000000003B5B_40CDAD8000000000_00 +FFFFFFFFC0000000_C1D0000000000000_00 +FFFFFFBFFE0FFFFF_C250007C00004000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +FFFFFFFFE0000000_C1C0000000000000_00 +FFFFFFFBF00007FF_C2103FFFE0040000_00 +01E986274F48EAAD_437E986274F48EAB_01 +FFFFFFFFF0000000_C1B0000000000000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFDFFFFFF_01 +FFFFFFFFFFFFCB5A_C0CA530000000000_00 +FFFFFFFFF8000000_C1A0000000000000_00 +7FF000000000FFFF_43DFFC0000000040_01 +00000003C2717FC3_420E138BFE180000_00 +FFFFFFFFFC000000_C190000000000000_00 +FFFFFFE00008001F_C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA_C130542600000000_00 +FFFFFFFFFE000000_C180000000000000_00 +0200000000000002_4380000000000000_01 +FFFFFFFFF8FDA53F_C19C096B04000000_00 +FFFFFFFFFF000000_C170000000000000_00 +F6000003FFFFFFFE_C3A3FFFFF8000000_01 +FFFFFFFFFFFFFFD0_C048000000000000_00 +FFFFFFFFFF800000_C160000000000000_00 +FFFFFFFFFFBFFF7E_C150002080000000_00 +00000000EE0FEA62_41EDC1FD4C400000_00 +FFFFFFFFFFC00000_C150000000000000_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000037F35EDC1D_424BF9AF6E0E8000_00 +FFFFFFFFFFE00000_C140000000000000_00 +FFFFFFF7FDFFFF7D_C220040001060000_00 +00000000000001AD_407AD00000000000_00 +FFFFFFFFFFF00000_C130000000000000_00 +FFFFFF0000100020_C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A_43C3F8B3FDE3FE30_01 +FFFFFFFFFFF80000_C120000000000000_00 +003FFFFFFFFC0001_434FFFFFFFFE0000_01 +000E48F9F4EBD30E_432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000_C110000000000000_00 +DFFFFFFFFFFBFFFE_C3C0000000000200_01 +FC91C23EE8C9424F_C38B71EE08B9B5EE_01 +FFFFFFFFFFFE0000_C100000000000000_00 +F7DFFBFFFFFFFFFE_C3A0400800000000_01 +000000002CAE080C_41C6570406000000_00 +FFFFFFFFFFFF0000_C0F0000000000000_00 +FFFFC00010000020_C2CFFFF7FFFFF000_00 +04D921F917B20E40_43936487E45EC839_00 +FFFFFFFFFFFF8000_C0E0000000000000_00 +F8000FFFFFFFFFFD_C39FFFC000000000_01 +FFF17C566BC7D811_C32D075328704FDE_00 +FFFFFFFFFFFFC000_C0D0000000000000_00 +00000000000000FE_406FC00000000000_00 +FFF82AC14930D386_C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000_C0C0000000000000_00 +00000000000003FC_408FE00000000000_00 +000E62EC60E119FC_432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000_C0B0000000000000_00 +FFFFEFF7FF7FFFFE_C2B0080080000200_00 +0E2B1ECF210EEDC5_43AC563D9E421DDC_01 +FFFFFFFFFFFFF800_C0A0000000000000_00 +00000000007FFF1F_415FFFC7C0000000_00 +FFFFFE534F5676F7_C27ACB0A98909000_00 +FFFFFFFFFFFFFC00_C090000000000000_00 +0000001004FFFFFD_423004FFFFFD0000_00 +0000035C939669F1_428AE49CB34F8800_00 +FFFFFFFFFFFFFE00_C080000000000000_00 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFE_01 +FFFFFFFFFFFFFF91_C05BC00000000000_00 +FFFFFFFFFFFFFF00_C070000000000000_00 +01FFFFFFFBFFEFFE_437FFFFFFFBFFF00_01 +000000000000016E_4076E00000000000_00 +FFFFFFFFFFFFFF80_C060000000000000_00 +FFF7FFFFFFFFF7FD_C320000000001006_00 +FFFFF8E2BCFAC553_C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0_C050000000000000_00 +FFFFFBFFFFFE0FFE_C290000007C00800_00 +00000001A4E704BF_41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0_C040000000000000_00 +1400007FFFFFFFFD_43B4000080000000_01 +FFFFFFFC93B187B4_C20B6273C2600000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +40000000007FFFFD_43D0000000002000_01 +000000000067D468_4159F51A00000000_00 +FFFFFFFFFFFFFFF8_C020000000000000_00 +007FFEFFFFFBFFFE_435FFFBFFFFF0000_01 +FFFFFFE26CEC79F8_C23D931386080000_00 +FFFFFFFFFFFFFFFC_C010000000000000_00 +00FFFFFF000000FF_436FFFFFE0000020_01 +FFFFFFFFE0D3983A_C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE_C000000000000000_00 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A_C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF_BFF0000000000000_00 +000008000000027E_42A000000004FC00_00 +000000000000F4E8_40EE9D0000000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFF83FFDF_C15F000840000000_00 +00000E11407887B2_42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +04000003FFFFFFF6_4390000010000000_01 +0000000000000513_40944C0000000000_00 +FFFFFFFFFFFFFFF7_C022000000000000_00 +BFFC00000000003E_C3D0010000000000_01 +00000008D7BBB75B_4221AF776EB60000_00 +FFFFFFFFFFFFFFEF_C031000000000000_00 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23_C14952EE80000000_00 +FFFFFFFFFFFFFFDF_C040800000000000_00 +FFBFDFFFBFFFFFFF_C350080010000000_01 +000000000000007F_405FC00000000000_00 +FFFFFFFFFFFFFFBF_C050400000000000_00 +00000007FF800003_421FFE00000C0000_00 +000000000002BB02_4105D81000000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEE7FF_C0F1801000000000_00 +00264B2B9BAD0DA2_43432595CDD686D1_00 +FFFFFFFFFFFFFEFF_C070100000000000_00 +0000000000100803_4130080300000000_00 +FF9B1DCB9F857D5E_C359388D181EA0A8_01 +FFFFFFFFFFFFFDFF_C080080000000000_00 +FFFFFFBFFFFFEFEE_C250000004048000_00 +F6FD7542899C1C6F_C3A205157AECC7C7_01 +FFFFFFFFFFFFFBFF_C090040000000000_00 +FF800000004001FF_C35FFFFFFFEFFF80_01 +0000000002BE4932_4185F24990000000_00 +FFFFFFFFFFFFF7FF_C0A0020000000000_00 +00001004000FFFFE_42B004000FFFFE00_00 +FFFFFF9DAA0123E0_C258957FB7080000_00 +FFFFFFFFFFFFEFFF_C0B0010000000000_00 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0_C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF_C0C0008000000000_00 +FE0FE00000000000_C37F020000000000_00 +0779ED944A4E2779_439DE7B65129389E_01 +FFFFFFFFFFFFBFFF_C0D0004000000000_00 +FBFFFE0400000000_C3900007F0000000_00 +0000010127E03666_4270127E03666000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +FFFFF0200000FFFE_C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEFFFF_C0F0001000000000_00 +FFEFFE0000080000_C33001FFFFF80000_00 +FFFFFFFFFD3354EA_C1866558B0000000_00 +FFFFFFFFFFFDFFFF_C100000800000000_00 +003FF0000003FFFE_434FF8000001FFFF_00 +0000006375B23F7B_4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF_C110000400000000_00 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000092117F38_41E2422FE7000000_00 +FFFFFFFFFFF7FFFF_C120000200000000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +00000000000008BE_40A17C0000000000_00 +FFFFFFFFFFEFFFFF_C130000100000000_00 +004000020FFFFFFF_4350000084000000_01 +FFFFB84C2D8BC9CB_C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF_C140000080000000_00 +00FFFFFFFFFFFFFD_4370000000000000_01 +00000023C2C6F284_4241E16379420000_00 +FFFFFFFFFFBFFFFF_C150000040000000_00 +FFFDDFFFFFFFFFFD_C301000000000018_00 +00000000746356C4_41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF_C160000020000000_00 +010000000000BFFF_4370000000000C00_01 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFEFFFFFF_C170000010000000_00 +FFFFBF7FFBFFFFFE_C2D0200100000080_00 +00000006386CE889_4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF_C180000008000000_00 +F00000F7FFFFFFFF_C3AFFFFE10000000_01 +FFFDFC53090C46A4_C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +0000000000800047_41600008E0000000_00 +FFFFFFFFD693872E_C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF_C1A0000002000000_00 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000026A7845E35_424353C22F1A8000_00 +FFFFFFFFEFFFFFFF_C1B0000001000000_00 +FFFFFFDFFFFFFBFD_C240000002018000_00 +000000001433D14C_41B433D14C000000_00 +FFFFFFFFDFFFFFFF_C1C0000000800000_00 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +F0F23E8068D3D84A_C3AE1B82FF2E584F_01 +FFFFFFFFBFFFFFFF_C1D0000000400000_00 +F7FFBFFFFFFFBFFF_C3A0008000000080_01 +FFFFBD29B7459087_C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF_C1E0000000200000_00 +FFFFFFF8FFFFBFFF_C21C000100040000_00 +FFFFFFFFFFEDDC06_C13223FA00000000_00 +FFFFFFFEFFFFFFFF_C1F0000000100000_00 +FFFFFFF80001FFFF_C21FFFF800040000_00 +0000000000002FF9_40C7FC8000000000_00 +FFFFFFFDFFFFFFFF_C200000000080000_00 +004000040000FFFF_4350000100004000_01 +FFFFFFFFFFFFFFF1_C02E000000000000_00 +FFFFFFFBFFFFFFFF_C210000000040000_00 +C0000000007FFFFA_C3CFFFFFFFFFC000_01 +FFFFFFFFFE053E2B_C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF_C220000000020000_00 +7FFE000007FFFFFF_43DFFF8000020000_01 +000000000000000D_402A000000000000_00 +FFFFFFEFFFFFFFFF_C230000000010000_00 +F80000000001007E_C39FFFFFFFFFFBFE_01 +FFFFED48424AD9D6_C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF_C240000000008000_00 +FFFFFE0001FEFFFF_C27FFFE010001000_00 +000000000000013B_4073B00000000000_00 +FFFFFFBFFFFFFFFF_C250000000004000_00 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0243_01 +FFFFFF7FFFFFFFFF_C260000000002000_00 +00FFF7FFFF7FFFFE_436FFEFFFFF00000_01 +0000000000000006_4018000000000000_00 +FFFFFEFFFFFFFFFF_C270000000001000_00 +FBFFFFBFFFBFFFFF_C390000100010000_01 +00000000000001BA_407BA00000000000_00 +FFFFFDFFFFFFFFFF_C280000000000800_00 +0000000040000082_41D0000020800000_00 +FF07A2BF5B689F89_C36F0BA81492EC0F_01 +FFFFFBFFFFFFFFFF_C290000000000400_00 +0000001FF8000008_423FF80000080000_00 +F87CAA7DE672DE8B_C39E0D5608663486_01 +FFFFF7FFFFFFFFFF_C2A0000000000200_00 +07FFF80000000002_439FFFE000000000_01 +0000000010A1E5B8_41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF_C2B0000000000100_00 +F7FFFFE00007FFFF_C3A000003FFFF000_01 +FFFFFFFFFFF6ADFC_C122A40800000000_00 +FFFFDFFFFFFFFFFF_C2C0000000000080_00 +FFFFFF03FFFFFFC0_C26F800000080000_00 +EA579475948F0032_C3B5A86B8A6B7100_01 +FFFFBFFFFFFFFFFF_C2D0000000000040_00 +FC00000000003FF6_C38FFFFFFFFFFE00_01 +002E677AC313BF60_434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF_C2E0000000000020_00 +02000007FF7FFFFF_438000003FFC0000_01 +0000000E999639F1_422D332C73E20000_00 +FFFEFFFFFFFFFFFF_C2F0000000000010_00 +FFFF83FFFFFFFFBE_C2DF000000001080_00 +000000000001537D_40F537D000000000_00 +FFFDFFFFFFFFFFFF_C300000000000008_00 +EFFFFFC00000003D_C3B0000040000000_01 +FFFFFFF21FEDFD35_C22BC02405960000_00 +FFFBFFFFFFFFFFFF_C310000000000004_00 +FFFFFFF0000007FE_C22FFFFFF0040000_00 +FFFFFFFFFFDE0839_C140FBE380000000_00 +FFF7FFFFFFFFFFFF_C320000000000002_00 +0000007FFFE000FF_425FFFF8003FC000_00 +FFFFFFFF79F30F48_C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF_C330000000000001_00 +FFFFFC13FFFFFFFD_C28F600000001800_00 +0000000000001B85_40BB850000000000_00 +FFDFFFFFFFFFFFFF_C340000000000000_01 +000008000007FFFE_42A000000FFFFC00_00 +12DB4409E5AE87E6_43B2DB4409E5AE88_01 +FFBFFFFFFFFFFFFF_C350000000000000_01 +FFFFFFFFFFF7BFEE_C120802400000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FF7FFFFFFFFFFFFF_C360000000000000_01 +000000001040FFFE_41B040FFFE000000_00 +00000909A09C13D3_42A213413827A600_00 +FEFFFFFFFFFFFFFF_C370000000000000_01 +FFFFFF01FFFFFF7F_C26FC00000102000_00 +FFFFFF72E7D2575D_C261A305B5146000_00 +FDFFFFFFFFFFFFFF_C380000000000000_01 +FFFFFFFFFFFEFFDB_C0F0025000000000_00 +0000000000000017_4037000000000000_00 +FBFFFFFFFFFFFFFF_C390000000000000_01 +100000001FFFFFF6_43B0000000200000_01 +000000114B12EF51_42314B12EF510000_00 +F7FFFFFFFFFFFFFF_C3A0000000000000_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFC_01 +FFFFFF769F3A5C2C_C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF_C3B0000000000000_01 +FFFFFFFDF7FFFFFD_C200400000180000_00 +FFFFFFFFFFFFFFF2_C02C000000000000_00 +DFFFFFFFFFFFFFFF_C3C0000000000000_01 +FFFFFFFFFE0007FF_C17FFF8010000000_00 +000000000000001E_403E000000000000_00 +BFFFFFFFFFFFFFFF_C3D0000000000000_01 +FFF800000009FFFF_C31FFFFFFFD80004_00 +0000000000007AA4_40DEA90000000000_00 +7FFFFFFFFFFFFFFF_43E0000000000000_01 +4080000000FFFFFF_43D0200000004000_01 +000000000DE7601D_41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF_43D0000000000000_01 +FFCFFFFFFFBFFFFE_C348000000200001_00 +FFFFFFFFFFFFFFCA_C04B000000000000_00 +1FFFFFFFFFFFFFFF_43C0000000000000_01 +000080400000003F_42E00800000007E0_00 +00000000001F75A5_413F75A500000000_00 +0FFFFFFFFFFFFFFF_43B0000000000000_01 +FFFFFFEFFFFFCFFE_C230000030020000_00 +FFFFFEE775887420_C27188A778BE0000_00 +07FFFFFFFFFFFFFF_43A0000000000000_01 +00000000000801FE_412003FC00000000_00 +0000000000213FF1_41409FF880000000_00 +03FFFFFFFFFFFFFF_4390000000000000_01 +07FEFFFFFFFFFFEE_439FFC0000000000_01 +0000000000000004_4010000000000000_00 +01FFFFFFFFFFFFFF_4380000000000000_01 +0000000820000003_4220400000060000_00 +FFFFFFF9AD105214_C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF_4370000000000000_01 +FFFFF00FFFFFFFBE_C2AFE00000008400_00 +FFFFFFFFFFCC48E7_C149DB8C80000000_00 +007FFFFFFFFFFFFF_4360000000000000_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB_C16E8B26A0000000_00 +003FFFFFFFFFFFFF_4350000000000000_01 +FFFFFF7FBFFFFFBF_C260080000082000_00 +FFFFFFFFFFF24425_C12B77B600000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFE00_01 +FFFFFF4E7115EC53_C26631DD4275A000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_C29FF00000010400_00 +FFFFFC2E539ADCFE_C28E8D6329181000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +00000055084732F3_42554211CCBCC000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_C3D0002000000000_01 +FFFFFFFFFFFF8543_C0DEAF4000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +FFFFFFFFFFFE491B_C0FB6E5000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_C38FFEFFFFFFFF00_01 +FFFFF16898822A24_C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF8200000000_01 +FFFFFF8FFE18C7BF_C25C0079CE104000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_C270001000003000_00 +00F03620C1266ED9_436E06C41824CDDB_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_C3D0204000000000_01 +FFFFFFFFFFFFFFD5_C045800000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_C31000001FF00008_00 +0000000000068684_411A1A1000000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_C3C0000010000000_01 +FFFFFFFFFFFFECF5_C0B30B0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_C2EFF7FFFFE00020_00 +0000000000000002_4000000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_C390000000000108_01 +0000000000000BC9_40A7920000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_C3DFE00000000008_01 +FFC274E35A70CD76_C34EC58E52C79945_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFE0000_01 +FFFFFFFF00E73AFC_C1EFE318A0800000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9_C0FEA17000000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +0000000000000033_4049800000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +FFFFFFEE6B141E1B_C23194EBE1E50000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_C1A3FFF002000000_00 +00000001AB310BA6_41FAB310BA600000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195_C0ACD60000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_C1DFFFFFFD400000_00 +00000019BA8D5559_4239BA8D55590000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_C390040000000000_01 +FFFFFFB6F062822D_C25243E75F74C000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +01CEAD9E2FB104A4_437CEAD9E2FB104A_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +FFFFFFFFFD681E78_C184BF0C40000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000018_4038000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000000_01 +FFFFFFFFFFFFFF95_C05AC00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000C00000000_01 +0000001697087B19_423697087B190000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_C390000000004400_01 +0000000E64BDFC55_422CC97BF8AA0000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_C38FFFFFFFF00000_01 +FFFED156A62AB849_C2F2EA959D547B70_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_C21F0040000C0000_00 +00015354EAE7C259_42F5354EAE7C2590_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFF0F4DF3C75_C22E164187160000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_C160003800000000_00 +FFFFFFDB5433CB9B_C24255E61A328000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_C280010010001800_00 +FFFFFFFFFFDEAE1F_C140A8F080000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7_C1F88CA213900000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000003757D8B12ED_428BABEC58976800_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_C27F808000001000_00 +00000A654064E046_42A4CA80C9C08C00_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A0000000000030_01 +FFFFFFFFFFFFFFE7_C039000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF8_01 +FFFFAD78B3D6C3B6_C2D4A1D30A4F1280_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +FFFFFFF70B77F34F_C221E91019620000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_C25FFFE400008000_00 +0000013EB4D67EC8_4273EB4D67EC8000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_C3D0000800010000_01 +0005CEAF34EA1DC7_43173ABCD3A8771C_00 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000360D0_410B068000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_4370040000000000_01 +00C000708FF1BA51_4368000E11FE374A_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_C39FF7FFFFF00000_01 +0F9E07DCC0BDC061_43AF3C0FB9817B81_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000008_01 +FFFFFFE1B9B2A079_C23E464D5F870000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_C31FFFFFFFFDFC04_00 +00000000001EB5B4_413EB5B400000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +00000000005AC607_4156B181C0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_C1F07FFFF0100000_00 +000005C5B9D66984_429716E759A61000_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_C3CFFF0000000800_00 +00001D06B372AA06_42BD06B372AA0600_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_ru.tv b/wally-pipelined/testbench/fp/i64_f64_ru.tv index eca72d40b..f2652d6cd 100644 --- a/wally-pipelined/testbench/fp/i64_f64_ru.tv +++ b/wally-pipelined/testbench/fp/i64_f64_ru.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 439FFFF7FFFFFFFE_01 -0000000032CC8B7A 41C96645BD000000_00 -0000000000000000 0000000000000000_00 -FFFFFFFFC0003FFE C1CFFFE001000000_00 -032C857F319EDE38 4389642BF98CF6F2_01 -0000000000000001 3FF0000000000000_00 -FFFFFBFFFFF8003E C29000001FFF0800_00 -00394C79B6D3007B 434CA63CDB69803E_01 -0000000000000002 4000000000000000_00 -FBFFFFF0000001FF C39000003FFFFFF8_01 -0000000001AE458D 417AE458D0000000_00 -0000000000000004 4010000000000000_00 -00040008000007FE 4310002000001FF8_00 -F9EB456140D88764 C39852EA7AFC9DE2_01 -0000000000000008 4020000000000000_00 -FFFFE400FFFFFFFE C2BBFF0000000200_00 -07DE834A248EDF36 439F7A0D28923B7D_01 -0000000000000010 4030000000000000_00 -00000003FF001FFF 420FF800FFF80000_00 -FFFFFFFFFFE385E2 C13C7A1E00000000_00 -0000000000000020 4040000000000000_00 -F0041FFFFFFFFFFF C3AFF7C000000000_01 -000000059EB1FD45 42167AC7F5140000_00 -0000000000000040 4050000000000000_00 -FFFFFFFFFFFCFFF9 C108003800000000_00 -FFFFFFFFFFFEDDFE C0F2202000000000_00 -0000000000000080 4060000000000000_00 -000000000003FF00 410FF80000000000_00 -00000000C89FF56B 41E913FEAD600000_00 -0000000000000100 4070000000000000_00 -000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 -1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEC0_01 -0000000000000200 4080000000000000_00 -FFFDF803FFFFFFFF C3003FE000000008_00 -FFFFFFFFFFF4766B C127132A00000000_00 -0000000000000400 4090000000000000_00 -0000080100000FFE 42A00200001FFC00_00 -000000000000000C 4028000000000000_00 -0000000000000800 40A0000000000000_00 -0048000000100000 4352000000040000_00 -FFE662A109109D0A C3399D5EF6EF62F6_00 -0000000000001000 40B0000000000000_00 -C000000037FFFFFE C3CFFFFFFFE40000_01 -FFFFFFFFFFFFFFE4 C03C000000000000_00 -0000000000002000 40C0000000000000_00 -F801000000100000 C39FFBFFFFFFC000_00 -FE114B79075F70EE C37EEB486F8A08F1_01 -0000000000004000 40D0000000000000_00 -100000000001003E 43B0000000000101_01 -00000000000003AC 408D600000000000_00 -0000000000008000 40E0000000000000_00 -200000FFFFFFF800 43C000007FFFFFFC_00 -00000044A3A3DBE5 425128E8F6F94000_00 -0000000000010000 40F0000000000000_00 -FFE0003EFFFFFFFF C33FFFC100000001_00 -FFFFFFFFFFFF1A91 C0ECADE000000000_00 -0000000000020000 4100000000000000_00 -FFFFF7C3FFFFFFFD C2A0780000000600_00 -0000000000003309 40C9848000000000_00 -0000000000040000 4110000000000000_00 -000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 -FFFFFFFFFFFFFF58 C065000000000000_00 -0000000000080000 4120000000000000_00 -FFFFFFDE01FFFFFE C240FF0000010000_00 -0000000000002980 40C4C00000000000_00 -0000000000100000 4130000000000000_00 -00000000FFF07FFF 41EFFE0FFFE00000_00 -000000000000005D 4057400000000000_00 -0000000000200000 4140000000000000_00 -000020FFDFFFFFFF 42C07FEFFFFFFF80_00 -FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 -0000000000400000 4150000000000000_00 -E0000000003FFFDF C3BFFFFFFFFFC000_01 -FFFFFDE3C1DEC43C C280E1F109DE2000_00 -0000000000800000 4160000000000000_00 -FFFF00000BFFFFFD C2EFFFFE80000060_00 -000000000030FFBE 41487FDF00000000_00 -0000000001000000 4170000000000000_00 -FFFE000007FFEFFD C2FFFFFF80010030_00 -FFFFFFFFEFDEED86 C1B021127A000000_00 -0000000002000000 4180000000000000_00 -F3FFFFFFFFBFFFFE C3A8000000008000_01 -000000001DA3FF45 41BDA3FF45000000_00 -0000000004000000 4190000000000000_00 -FFFFFFFF00010007 C1EFFFDFFF200000_00 -FFFFFFFE9B1BCB54 C1F64E434AC00000_00 -0000000008000000 41A0000000000000_00 -00004000004001FE 42D0000010007F80_00 -F27DD19DE6563714 C3AB045CC4335391_01 -0000000010000000 41B0000000000000_00 -FFC00000004007FE C34FFFFFFFDFFC01_00 -000000000001A359 40FA359000000000_00 -0000000020000000 41C0000000000000_00 -0000000003C000FE 418E0007F0000000_00 -FFFFFFFFFE62EC20 C179D13E00000000_00 -0000000040000000 41D0000000000000_00 -000000003FFFFFFD 41CFFFFFFE800000_00 -000000000000285F 40C42F8000000000_00 -0000000080000000 41E0000000000000_00 -FFFFFFFFBFFFF00F C1D00003FC400000_00 -FFFFF836F99DBAA8 C29F241989156000_00 -0000000100000000 41F0000000000000_00 -00000020003FFEFE 4240001FFF7F0000_00 -0033466832042D47 4349A334190216A4_01 -0000000200000000 4200000000000000_00 -FFFFFFFFFFFFF887 C09DE40000000000_00 -00000000003829C8 414C14E400000000_00 -0000000400000000 4210000000000000_00 -00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 -0000000FB77C672B 422F6EF8CE560000_00 -0000000800000000 4220000000000000_00 -08003FFDFFFFFFFE 43A0007FFC000000_01 -0000000000001B78 40BB780000000000_00 -0000001000000000 4230000000000000_00 -FF7FFFFFFFEFDFFF C360000000020400_01 -0000000000000071 405C400000000000_00 -0000002000000000 4240000000000000_00 -000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 -FFFFFFFFFFFFFF86 C05E800000000000_00 -0000004000000000 4250000000000000_00 -0800000000040800 43A0000000000810_00 -FFF8A60D9E19F17E C31D67C987983A08_00 -0000008000000000 4260000000000000_00 -000077FFF0000000 42DDFFFC00000000_00 -FFFFFFFFF7506DBA C1A15F248C000000_00 -0000010000000000 4270000000000000_00 -FFFFFFFFFFFEFBF7 C0F0409000000000_00 -FFFFFFFFFEA42AC9 C175BD5370000000_00 -0000020000000000 4280000000000000_00 -0000107FFFFFDFFD 42B07FFFFFDFFD00_00 -FFE7AA3F2BDACC89 C33855C0D4253377_00 -0000040000000000 4290000000000000_00 -FFF8040000040000 C31FEFFFFFF00000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -0000080000000000 42A0000000000000_00 -FFFF80000800001F C2DFFFFDFFFFF840_00 -FFFDF681DECDADC9 C3004BF1099291B8_00 -0000100000000000 42B0000000000000_00 -FFFFFEFFFFE0007F C2700001FFF81000_00 -FFFFFFFFFFFFCFBE C0C8210000000000_00 -0000200000000000 42C0000000000000_00 -0000000901FFFFFD 422203FFFFFA0000_00 -FEC01FECA24DE1B0 C373FE0135DB21E5_00 -0000400000000000 42D0000000000000_00 -F7FFFFFFDFFF7FFF C3A0000000400100_01 -F858A66761669936 C39E9D66627A659B_01 -0000800000000000 42E0000000000000_00 -FFFEFF800000003E C2F007FFFFFFFC20_00 -F716EA43FAC45C97 C3A1D22B780A7746_01 -0001000000000000 42F0000000000000_00 -FFFFFFFFFFFFFFC6 C04D000000000000_00 -0024D70EC7661FD8 43426B8763B30FEC_00 -0002000000000000 4300000000000000_00 -C07FFFFFFFFFFFFE C3CFC00000000000_01 -FFD956DBD0AEE817 C343549217A88BF4_01 -0004000000000000 4310000000000000_00 -020003EFFFFFFFFE 4380001F80000000_01 -FFFFFFFFFFFF4300 C0E7A00000000000_00 -0008000000000000 4320000000000000_00 -4000000004002000 43D0000000010008_00 -C12EDF40F41F6021 C3CF68905F85F04F_01 -0010000000000000 4330000000000000_00 -FF9000000000001D C35BFFFFFFFFFFF8_01 -FFFFFFF83DE950F6 C21F085ABC280000_00 -0020000000000000 4340000000000000_00 -800003FFFFFC0000 C3DFFFFF00000100_00 -FE2B59CB3A604D69 C37D4A634C59FB29_01 -0040000000000000 4350000000000000_00 -7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFF0_01 -000000A37C210862 42646F84210C4000_00 -0080000000000000 4360000000000000_00 -0002000002000002 4300000010000010_00 -FFFFB65CD8617789 C2D268C9E7A21DC0_00 -0100000000000000 4370000000000000_00 -00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 -FFFFFFFFFFFFF01D C0AFC60000000000_00 -0200000000000000 4380000000000000_00 -1000008000003FFF 43B0000080000040_01 -000000000D098D19 41AA131A32000000_00 -0400000000000000 4390000000000000_00 -03FFFFFFFFFFF5FF 438FFFFFFFFFFFB0_01 -000006B3BD2C7BEF 429ACEF4B1EFBC00_00 -0800000000000000 43A0000000000000_00 -00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 -FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 -1000000000000000 43B0000000000000_00 -001FFFC000000FFD 433FFFC000000FFD_00 -FFFFFFFFFFFFFF21 C06BE00000000000_00 -2000000000000000 43C0000000000000_00 -0000000041DFFFFF 41D077FFFFC00000_00 -FFFFFFFFFC648262 C18CDBECF0000000_00 -4000000000000000 43D0000000000000_00 -C0001FFFFFFFFFFB C3CFFFF000000000_01 -FFFFFF7353AC45D2 C261958A7745C000_00 -8000000000000000 C3E0000000000000_00 -FFFFFFFFFFE7EFFF C138100100000000_00 -0000000000A1202D 41642405A0000000_00 -C000000000000000 C3D0000000000000_00 -FFFFFFFFFFFF5F7F C0E4102000000000_00 -000000000040CA70 4150329C00000000_00 -E000000000000000 C3C0000000000000_00 -0000200201FFFFFE 42C00100FFFFFF00_00 -00000003B55D87D4 420DAAEC3EA00000_00 -F000000000000000 C3B0000000000000_00 -FF80000DFFFFFFFF C35FFFFC80000000_01 -000000010510FAEF 41F0510FAEF00000_00 -F800000000000000 C3A0000000000000_00 -0003FFF00000000F 430FFF8000000078_00 -000000000000724A 40DC928000000000_00 -FC00000000000000 C390000000000000_00 -FFFFFFDF80000002 C2403FFFFFFF0000_00 -0000000000000064 4059000000000000_00 -FE00000000000000 C380000000000000_00 -FEFFFFFFFFF800FE C370000000007FF0_01 -FFFFFFC2C6222702 C24E9CEEEC7F0000_00 -FF00000000000000 C370000000000000_00 -0000000408000002 4210200000080000_00 -000000E96DF1CB41 426D2DBE39682000_00 -FF80000000000000 C360000000000000_00 -007FFFFFFFFFF9FE 435FFFFFFFFFFE80_01 -F727F174DEE7DC85 C3A1B01D16423046_01 -FFC0000000000000 C350000000000000_00 -8000000003FFFEFE C3DFFFFFFFFF0000_01 -FFFFFFFFFFF0BD5B C12E854A00000000_00 -FFE0000000000000 C340000000000000_00 -0BEFFFFFFFFFFFFF 43A7E00000000000_01 -000000000002790C 4103C86000000000_00 -FFF0000000000000 C330000000000000_00 -FFFFFFFFFFEFFBFA C130040600000000_00 -000000169E75DF01 42369E75DF010000_00 -FFF8000000000000 C320000000000000_00 -00000007FEFFDFFF 421FFBFF7FFC0000_00 -000000000000000E 402C000000000000_00 -FFFC000000000000 C310000000000000_00 -0003FFFE0007FFFE 430FFFF0003FFFF0_00 -FFFFFFFFFFF28622 C12AF3BC00000000_00 -FFFE000000000000 C300000000000000_00 -FFFFFF7FFFFDF7FF C260000041002000_00 -00072F0EC496FE21 431CBC3B125BF884_00 -FFFF000000000000 C2F0000000000000_00 -DFBFFFFFFFFFFFFE C3C0200000000000_01 -0000000000FC1FCA 416F83F940000000_00 -FFFF800000000000 C2E0000000000000_00 -00000FFF800FFFFE 42AFFF001FFFFC00_00 -FFFF5194E4A9C2CE C2E5CD636AC7A640_00 -FFFFC00000000000 C2D0000000000000_00 -00000002100007FD 420080003FE80000_00 -FFFFFFFFFFC2D8FE C14E938100000000_00 -FFFFE00000000000 C2C0000000000000_00 -000000000007FF6E 411FFDB800000000_00 -000000000001766E 40F766E000000000_00 -FFFFF00000000000 C2B0000000000000_00 -0040000400000002 4350000100000001_01 -0000000000007841 40DE104000000000_00 -FFFFF80000000000 C2A0000000000000_00 -3DFFFFFFFFFFFF7E 43CF000000000000_01 -FFFFFFE549E17E30 C23AB61E81D00000_00 -FFFFFC0000000000 C290000000000000_00 -FFFFFFFFFFFFFEE1 C071F00000000000_00 -FFFFFFFFFFFFFFE7 C039000000000000_00 -FFFFFE0000000000 C280000000000000_00 -000000000EFFFFDF 41ADFFFFBE000000_00 -FFFFFFFFFFFFFF73 C061A00000000000_00 -FFFFFF0000000000 C270000000000000_00 -FD00000008000000 C387FFFFFFC00000_00 -000000000001DBB1 40FDBB1000000000_00 -FFFFFF8000000000 C260000000000000_00 -FFFFFFFFFFF8007F C11FFE0400000000_00 -FFFFFFFEFD10A515 C1F02EF5AEB00000_00 -FFFFFFC000000000 C250000000000000_00 -FFEFFFFFFFFFFFFE C330000000000002_00 -FAB02984F6283B6C C3953F59EC275F12_01 -FFFFFFE000000000 C240000000000000_00 -FFFFFFBC000001FE C250FFFFFF808000_00 -FEB087C6B9FE7FE0 C374F78394601802_00 -FFFFFFF000000000 C230000000000000_00 -FFF80001000007FE C31FFFFBFFFFE008_00 -00F2762EA6837956 436E4EC5D4D06F2B_01 -FFFFFFF800000000 C220000000000000_00 -FFF7E0FFFFFFFFFE C3203E0000000004_00 -00002E1175484626 42C708BAA4231300_00 -FFFFFFFC00000000 C210000000000000_00 -0000200020000FFE 42C000100007FF00_00 -000000000000068F 409A3C0000000000_00 -FFFFFFFE00000000 C200000000000000_00 -021FFFFFFFFBFFFF 4380FFFFFFFFE000_01 -FFFFFFFFFFFFFFF9 C01C000000000000_00 -FFFFFFFF00000000 C1F0000000000000_00 -FFFFFFD0000FFFFD C247FFF800018000_00 -000000BDF6658B83 4267BECCB1706000_00 -FFFFFFFF80000000 C1E0000000000000_00 -1000001FFDFFFFFF 43B000001FFE0000_01 -0000000000003B5B 40CDAD8000000000_00 -FFFFFFFFC0000000 C1D0000000000000_00 -FFFFFFBFFE0FFFFF C250007C00004000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -FFFFFFFFE0000000 C1C0000000000000_00 -FFFFFFFBF00007FF C2103FFFE0040000_00 -01E986274F48EAAD 437E986274F48EAB_01 -FFFFFFFFF0000000 C1B0000000000000_00 -1FFFFFFDFFFFFF7F 43BFFFFFFE000000_01 -FFFFFFFFFFFFCB5A C0CA530000000000_00 -FFFFFFFFF8000000 C1A0000000000000_00 -7FF000000000FFFF 43DFFC0000000040_01 -00000003C2717FC3 420E138BFE180000_00 -FFFFFFFFFC000000 C190000000000000_00 -FFFFFFE00008001F C23FFFF7FFE10000_00 -FFFFFFFFFFEFABDA C130542600000000_00 -FFFFFFFFFE000000 C180000000000000_00 -0200000000000002 4380000000000001_01 -FFFFFFFFF8FDA53F C19C096B04000000_00 -FFFFFFFFFF000000 C170000000000000_00 -F6000003FFFFFFFE C3A3FFFFF8000000_01 -FFFFFFFFFFFFFFD0 C048000000000000_00 -FFFFFFFFFF800000 C160000000000000_00 -FFFFFFFFFFBFFF7E C150002080000000_00 -00000000EE0FEA62 41EDC1FD4C400000_00 -FFFFFFFFFFC00000 C150000000000000_00 -0000007FFF9FFFFD 425FFFE7FFFF4000_00 -00000037F35EDC1D 424BF9AF6E0E8000_00 -FFFFFFFFFFE00000 C140000000000000_00 -FFFFFFF7FDFFFF7D C220040001060000_00 -00000000000001AD 407AD00000000000_00 -FFFFFFFFFFF00000 C130000000000000_00 -FFFFFF0000100020 C26FFFFDFFFC0000_00 -27F167FBC7FC5F9A 43C3F8B3FDE3FE30_01 -FFFFFFFFFFF80000 C120000000000000_00 -003FFFFFFFFC0001 434FFFFFFFFE0001_01 -000E48F9F4EBD30E 432C91F3E9D7A61C_00 -FFFFFFFFFFFC0000 C110000000000000_00 -DFFFFFFFFFFBFFFE C3C0000000000200_01 -FC91C23EE8C9424F C38B71EE08B9B5ED_01 -FFFFFFFFFFFE0000 C100000000000000_00 -F7DFFBFFFFFFFFFE C3A0400800000000_01 -000000002CAE080C 41C6570406000000_00 -FFFFFFFFFFFF0000 C0F0000000000000_00 -FFFFC00010000020 C2CFFFF7FFFFF000_00 -04D921F917B20E40 43936487E45EC839_00 -FFFFFFFFFFFF8000 C0E0000000000000_00 -F8000FFFFFFFFFFD C39FFFC000000000_01 -FFF17C566BC7D811 C32D075328704FDE_00 -FFFFFFFFFFFFC000 C0D0000000000000_00 -00000000000000FE 406FC00000000000_00 -FFF82AC14930D386 C31F54FADB3CB1E8_00 -FFFFFFFFFFFFE000 C0C0000000000000_00 -00000000000003FC 408FE00000000000_00 -000E62EC60E119FC 432CC5D8C1C233F8_00 -FFFFFFFFFFFFF000 C0B0000000000000_00 -FFFFEFF7FF7FFFFE C2B0080080000200_00 -0E2B1ECF210EEDC5 43AC563D9E421DDC_01 -FFFFFFFFFFFFF800 C0A0000000000000_00 -00000000007FFF1F 415FFFC7C0000000_00 -FFFFFE534F5676F7 C27ACB0A98909000_00 -FFFFFFFFFFFFFC00 C090000000000000_00 -0000001004FFFFFD 423004FFFFFD0000_00 -0000035C939669F1 428AE49CB34F8800_00 -FFFFFFFFFFFFFE00 C080000000000000_00 -1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFE_01 -FFFFFFFFFFFFFF91 C05BC00000000000_00 -FFFFFFFFFFFFFF00 C070000000000000_00 -01FFFFFFFBFFEFFE 437FFFFFFFBFFF00_01 -000000000000016E 4076E00000000000_00 -FFFFFFFFFFFFFF80 C060000000000000_00 -FFF7FFFFFFFFF7FD C320000000001006_00 -FFFFF8E2BCFAC553 C29C750C14EAB400_00 -FFFFFFFFFFFFFFC0 C050000000000000_00 -FFFFFBFFFFFE0FFE C290000007C00800_00 -00000001A4E704BF 41FA4E704BF00000_00 -FFFFFFFFFFFFFFE0 C040000000000000_00 -1400007FFFFFFFFD 43B4000080000000_01 -FFFFFFFC93B187B4 C20B6273C2600000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -40000000007FFFFD 43D0000000002000_01 -000000000067D468 4159F51A00000000_00 -FFFFFFFFFFFFFFF8 C020000000000000_00 -007FFEFFFFFBFFFE 435FFFBFFFFF0000_01 -FFFFFFE26CEC79F8 C23D931386080000_00 -FFFFFFFFFFFFFFFC C010000000000000_00 -00FFFFFF000000FF 436FFFFFE0000020_01 -FFFFFFFFE0D3983A C1BF2C67C6000000_00 -FFFFFFFFFFFFFFFE C000000000000000_00 -00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 -FFFFFFFDF4A7088A C2005AC7BBB00000_00 -FFFFFFFFFFFFFFFF BFF0000000000000_00 -000008000000027E 42A000000004FC00_00 -000000000000F4E8 40EE9D0000000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFF83FFDF C15F000840000000_00 -00000E11407887B2 42AC2280F10F6400_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -04000003FFFFFFF6 4390000010000000_01 -0000000000000513 40944C0000000000_00 -FFFFFFFFFFFFFFF7 C022000000000000_00 -BFFC00000000003E C3D000FFFFFFFFFF_01 -00000008D7BBB75B 4221AF776EB60000_00 -FFFFFFFFFFFFFFEF C031000000000000_00 -000FFFFBFFFC0000 432FFFF7FFF80000_00 -FFFFFFFFFFCD5A23 C14952EE80000000_00 -FFFFFFFFFFFFFFDF C040800000000000_00 -FFBFDFFFBFFFFFFF C350080010000000_01 -000000000000007F 405FC00000000000_00 -FFFFFFFFFFFFFFBF C050400000000000_00 -00000007FF800003 421FFE00000C0000_00 -000000000002BB02 4105D81000000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEE7FF C0F1801000000000_00 -00264B2B9BAD0DA2 43432595CDD686D1_00 -FFFFFFFFFFFFFEFF C070100000000000_00 -0000000000100803 4130080300000000_00 -FF9B1DCB9F857D5E C359388D181EA0A8_01 -FFFFFFFFFFFFFDFF C080080000000000_00 -FFFFFFBFFFFFEFEE C250000004048000_00 -F6FD7542899C1C6F C3A205157AECC7C7_01 -FFFFFFFFFFFFFBFF C090040000000000_00 -FF800000004001FF C35FFFFFFFEFFF80_01 -0000000002BE4932 4185F24990000000_00 -FFFFFFFFFFFFF7FF C0A0020000000000_00 -00001004000FFFFE 42B004000FFFFE00_00 -FFFFFF9DAA0123E0 C258957FB7080000_00 -FFFFFFFFFFFFEFFF C0B0010000000000_00 -00000001FDFFFDFE 41FFDFFFDFE00000_00 -FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 -FFFFFFFFFFFFDFFF C0C0008000000000_00 -FE0FE00000000000 C37F020000000000_00 -0779ED944A4E2779 439DE7B65129389E_01 -FFFFFFFFFFFFBFFF C0D0004000000000_00 -FBFFFE0400000000 C3900007F0000000_00 -0000010127E03666 4270127E03666000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -FFFFF0200000FFFE C2AFBFFFFE000400_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEFFFF C0F0001000000000_00 -FFEFFE0000080000 C33001FFFFF80000_00 -FFFFFFFFFD3354EA C1866558B0000000_00 -FFFFFFFFFFFDFFFF C100000800000000_00 -003FF0000003FFFE 434FF8000001FFFF_00 -0000006375B23F7B 4258DD6C8FDEC000_00 -FFFFFFFFFFFBFFFF C110000400000000_00 -000407FFFFFFFFF6 43101FFFFFFFFFD8_00 -0000000092117F38 41E2422FE7000000_00 -FFFFFFFFFFF7FFFF C120000200000000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -00000000000008BE 40A17C0000000000_00 -FFFFFFFFFFEFFFFF C130000100000000_00 -004000020FFFFFFF 4350000084000000_01 -FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 -FFFFFFFFFFDFFFFF C140000080000000_00 -00FFFFFFFFFFFFFD 4370000000000000_01 -00000023C2C6F284 4241E16379420000_00 -FFFFFFFFFFBFFFFF C150000040000000_00 -FFFDDFFFFFFFFFFD C301000000000018_00 -00000000746356C4 41DD18D5B1000000_00 -FFFFFFFFFF7FFFFF C160000020000000_00 -010000000000BFFF 4370000000000C00_01 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFEFFFFFF C170000010000000_00 -FFFFBF7FFBFFFFFE C2D0200100000080_00 -00000006386CE889 4218E1B3A2240000_00 -FFFFFFFFFDFFFFFF C180000008000000_00 -F00000F7FFFFFFFF C3AFFFFE10000000_01 -FFFDFC53090C46A4 C3001D67B79DCAE0_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -0000000000800047 41600008E0000000_00 -FFFFFFFFD693872E C1C4B63C69000000_00 -FFFFFFFFF7FFFFFF C1A0000002000000_00 -000000007FBFFBFF 41DFEFFEFFC00000_00 -00000026A7845E35 424353C22F1A8000_00 -FFFFFFFFEFFFFFFF C1B0000001000000_00 -FFFFFFDFFFFFFBFD C240000002018000_00 -000000001433D14C 41B433D14C000000_00 -FFFFFFFFDFFFFFFF C1C0000000800000_00 -0001FFFFFFE0000E 42FFFFFFFE0000E0_00 -F0F23E8068D3D84A C3AE1B82FF2E584F_01 -FFFFFFFFBFFFFFFF C1D0000000400000_00 -F7FFBFFFFFFFBFFF C3A0008000000080_01 -FFFFBD29B7459087 C2D0B5922E9BDE40_00 -FFFFFFFF7FFFFFFF C1E0000000200000_00 -FFFFFFF8FFFFBFFF C21C000100040000_00 -FFFFFFFFFFEDDC06 C13223FA00000000_00 -FFFFFFFEFFFFFFFF C1F0000000100000_00 -FFFFFFF80001FFFF C21FFFF800040000_00 -0000000000002FF9 40C7FC8000000000_00 -FFFFFFFDFFFFFFFF C200000000080000_00 -004000040000FFFF 4350000100004000_01 -FFFFFFFFFFFFFFF1 C02E000000000000_00 -FFFFFFFBFFFFFFFF C210000000040000_00 -C0000000007FFFFA C3CFFFFFFFFFC000_01 -FFFFFFFFFE053E2B C17FAC1D50000000_00 -FFFFFFF7FFFFFFFF C220000000020000_00 -7FFE000007FFFFFF 43DFFF8000020000_01 -000000000000000D 402A000000000000_00 -FFFFFFEFFFFFFFFF C230000000010000_00 -F80000000001007E C39FFFFFFFFFFBFE_01 -FFFFED48424AD9D6 C2B2B7BDB5262A00_00 -FFFFFFDFFFFFFFFF C240000000008000_00 -FFFFFE0001FEFFFF C27FFFE010001000_00 -000000000000013B 4073B00000000000_00 -FFFFFFBFFFFFFFFF C250000000004000_00 -0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 -4A16BD4128090C83 43D285AF504A0244_01 -FFFFFF7FFFFFFFFF C260000000002000_00 -00FFF7FFFF7FFFFE 436FFEFFFFF00000_01 -0000000000000006 4018000000000000_00 -FFFFFEFFFFFFFFFF C270000000001000_00 -FBFFFFBFFFBFFFFF C390000100010000_01 -00000000000001BA 407BA00000000000_00 -FFFFFDFFFFFFFFFF C280000000000800_00 -0000000040000082 41D0000020800000_00 -FF07A2BF5B689F89 C36F0BA81492EC0E_01 -FFFFFBFFFFFFFFFF C290000000000400_00 -0000001FF8000008 423FF80000080000_00 -F87CAA7DE672DE8B C39E0D5608663485_01 -FFFFF7FFFFFFFFFF C2A0000000000200_00 -07FFF80000000002 439FFFE000000001_01 -0000000010A1E5B8 41B0A1E5B8000000_00 -FFFFEFFFFFFFFFFF C2B0000000000100_00 -F7FFFFE00007FFFF C3A000003FFFF000_01 -FFFFFFFFFFF6ADFC C122A40800000000_00 -FFFFDFFFFFFFFFFF C2C0000000000080_00 -FFFFFF03FFFFFFC0 C26F800000080000_00 -EA579475948F0032 C3B5A86B8A6B70FF_01 -FFFFBFFFFFFFFFFF C2D0000000000040_00 -FC00000000003FF6 C38FFFFFFFFFFE00_01 -002E677AC313BF60 434733BD6189DFB0_00 -FFFF7FFFFFFFFFFF C2E0000000000020_00 -02000007FF7FFFFF 438000003FFC0000_01 -0000000E999639F1 422D332C73E20000_00 -FFFEFFFFFFFFFFFF C2F0000000000010_00 -FFFF83FFFFFFFFBE C2DF000000001080_00 -000000000001537D 40F537D000000000_00 -FFFDFFFFFFFFFFFF C300000000000008_00 -EFFFFFC00000003D C3B000003FFFFFFF_01 -FFFFFFF21FEDFD35 C22BC02405960000_00 -FFFBFFFFFFFFFFFF C310000000000004_00 -FFFFFFF0000007FE C22FFFFFF0040000_00 -FFFFFFFFFFDE0839 C140FBE380000000_00 -FFF7FFFFFFFFFFFF C320000000000002_00 -0000007FFFE000FF 425FFFF8003FC000_00 -FFFFFFFF79F30F48 C1E0C19E17000000_00 -FFEFFFFFFFFFFFFF C330000000000001_00 -FFFFFC13FFFFFFFD C28F600000001800_00 -0000000000001B85 40BB850000000000_00 -FFDFFFFFFFFFFFFF C340000000000000_01 -000008000007FFFE 42A000000FFFFC00_00 -12DB4409E5AE87E6 43B2DB4409E5AE88_01 -FFBFFFFFFFFFFFFF C350000000000000_01 -FFFFFFFFFFF7BFEE C120802400000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FF7FFFFFFFFFFFFF C360000000000000_01 -000000001040FFFE 41B040FFFE000000_00 -00000909A09C13D3 42A213413827A600_00 -FEFFFFFFFFFFFFFF C370000000000000_01 -FFFFFF01FFFFFF7F C26FC00000102000_00 -FFFFFF72E7D2575D C261A305B5146000_00 -FDFFFFFFFFFFFFFF C380000000000000_01 -FFFFFFFFFFFEFFDB C0F0025000000000_00 -0000000000000017 4037000000000000_00 -FBFFFFFFFFFFFFFF C390000000000000_01 -100000001FFFFFF6 43B0000000200000_01 -000000114B12EF51 42314B12EF510000_00 -F7FFFFFFFFFFFFFF C3A0000000000000_01 -0407FFFFFFFFFEFF 43901FFFFFFFFFFC_01 -FFFFFF769F3A5C2C C2612C18B47A8000_00 -EFFFFFFFFFFFFFFF C3B0000000000000_01 -FFFFFFFDF7FFFFFD C200400000180000_00 -FFFFFFFFFFFFFFF2 C02C000000000000_00 -DFFFFFFFFFFFFFFF C3C0000000000000_01 -FFFFFFFFFE0007FF C17FFF8010000000_00 -000000000000001E 403E000000000000_00 -BFFFFFFFFFFFFFFF C3D0000000000000_01 -FFF800000009FFFF C31FFFFFFFD80004_00 -0000000000007AA4 40DEA90000000000_00 -7FFFFFFFFFFFFFFF 43E0000000000000_01 -4080000000FFFFFF 43D0200000004000_01 -000000000DE7601D 41ABCEC03A000000_00 -3FFFFFFFFFFFFFFF 43D0000000000000_01 -FFCFFFFFFFBFFFFE C348000000200001_00 -FFFFFFFFFFFFFFCA C04B000000000000_00 -1FFFFFFFFFFFFFFF 43C0000000000000_01 -000080400000003F 42E00800000007E0_00 -00000000001F75A5 413F75A500000000_00 -0FFFFFFFFFFFFFFF 43B0000000000000_01 -FFFFFFEFFFFFCFFE C230000030020000_00 -FFFFFEE775887420 C27188A778BE0000_00 -07FFFFFFFFFFFFFF 43A0000000000000_01 -00000000000801FE 412003FC00000000_00 -0000000000213FF1 41409FF880000000_00 -03FFFFFFFFFFFFFF 4390000000000000_01 -07FEFFFFFFFFFFEE 439FFC0000000000_01 -0000000000000004 4010000000000000_00 -01FFFFFFFFFFFFFF 4380000000000000_01 -0000000820000003 4220400000060000_00 -FFFFFFF9AD105214 C2194BBEB7B00000_00 -00FFFFFFFFFFFFFF 4370000000000000_01 -FFFFF00FFFFFFFBE C2AFE00000008400_00 -FFFFFFFFFFCC48E7 C149DB8C80000000_00 -007FFFFFFFFFFFFF 4360000000000000_01 -00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 -FFFFFFFFFF0BA6CB C16E8B26A0000000_00 -003FFFFFFFFFFFFF 4350000000000000_01 -FFFFFF7FBFFFFFBF C260080000082000_00 -FFFFFFFFFFF24425 C12B77B600000000_00 -001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 -200000001FFBFFFF 43C00000000FFE00_01 -FFFFFF4E7115EC53 C26631DD4275A000_00 -000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 -FFFFF803FFFFFFBF C29FF00000010400_00 -FFFFFC2E539ADCFE C28E8D6329181000_00 -0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -00000055084732F3 42554211CCBCC000_00 -0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 -BFFF7FFFFFFFFE00 C3D0002000000000_01 -FFFFFFFFFFFF8543 C0DEAF4000000000_00 -0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 -0000001FFBFFE000 423FFBFFE0000000_00 -FFFFFFFFFFFE491B C0FB6E5000000000_00 -0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 -FC00200000001FFE C38FFEFFFFFFFF00_01 -FFFFF16898822A24 C2AD2ECEFBABB800_00 -00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 -3FFF03FFFFFFFFFE 43CFFF8200000000_01 -FFFFFF8FFE18C7BF C25C0079CE104000_00 -00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 -FFFFFEFFFEFFFFFD C270001000003000_00 -00F03620C1266ED9 436E06C41824CDDC_01 -00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 -BF7EFFFFFFFFFFFF C3D0204000000000_01 -FFFFFFFFFFFFFFD5 C045800000000000_00 -00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 -FFFBFFFFF803FFFE C31000001FF00008_00 -0000000000068684 411A1A1000000000_00 -000007FFFFFFFFFF 429FFFFFFFFFFC00_00 -DFFFFFE00000001E C3C000000FFFFFFF_01 -FFFFFFFFFFFFECF5 C0B30B0000000000_00 -000003FFFFFFFFFF 428FFFFFFFFFF800_00 -FFFF00400000FFFF C2EFF7FFFFE00020_00 -0000000000000002 4000000000000000_00 -000001FFFFFFFFFF 427FFFFFFFFFF000_00 -FBFFFFFFFFFFBDFE C390000000000108_01 -0000000000000BC9 40A7920000000000_00 -000000FFFFFFFFFF 426FFFFFFFFFE000_00 -807FFFFFFFFFDFFE C3DFE00000000008_01 -FFC274E35A70CD76 C34EC58E52C79945_00 -0000007FFFFFFFFF 425FFFFFFFFFC000_00 -0FFFFFFFFEFFFFFD 43AFFFFFFFFE0000_01 -FFFFFFFF00E73AFC C1EFE318A0800000_00 -0000003FFFFFFFFF 424FFFFFFFFF8000_00 -FFC000000001000E C34FFFFFFFFF7FF9_00 -FFFFFFFFFFFE15E9 C0FEA17000000000_00 -0000001FFFFFFFFF 423FFFFFFFFF0000_00 -0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 -0000000000000033 4049800000000000_00 -0000000FFFFFFFFF 422FFFFFFFFE0000_00 -000000001FFFBFFF 41BFFFBFFF000000_00 -FFFFFFEE6B141E1B C23194EBE1E50000_00 -00000007FFFFFFFF 421FFFFFFFFC0000_00 -FFFFFFFFF60007FF C1A3FFF002000000_00 -00000001AB310BA6 41FAB310BA600000_00 -00000003FFFFFFFF 420FFFFFFFF80000_00 -0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 -FFFFFFFFFFFFF195 C0ACD60000000000_00 -00000001FFFFFFFF 41FFFFFFFFF00000_00 -FFFFFFFF8000000B C1DFFFFFFD400000_00 -00000019BA8D5559 4239BA8D55590000_00 -00000000FFFFFFFF 41EFFFFFFFE00000_00 -FBFEFFFFFFFFFFF9 C390040000000000_01 -FFFFFFB6F062822D C25243E75F74C000_00 -000000007FFFFFFF 41DFFFFFFFC00000_00 -0001000000000082 42F0000000000820_00 -01CEAD9E2FB104A4 437CEAD9E2FB104B_01 -000000003FFFFFFF 41CFFFFFFF800000_00 -000003FFFFFFFF7C 428FFFFFFFFBE000_00 -FFFFFFFFFD681E78 C184BF0C40000000_00 -000000001FFFFFFF 41BFFFFFFF000000_00 -00002000400001FF 42C000200000FF80_00 -0000000000000018 4038000000000000_00 -000000000FFFFFFF 41AFFFFFFE000000_00 -3FFF80000000003E 43CFFFC000000001_01 -FFFFFFFFFFFFFF95 C05AC00000000000_00 -0000000007FFFFFF 419FFFFFFC000000_00 -010000BFFFFFFFFF 4370000C00000000_01 -0000001697087B19 423697087B190000_00 -0000000003FFFFFF 418FFFFFF8000000_00 -FBFFFFFFFFEEFFFD C390000000004400_01 -0000000E64BDFC55 422CC97BF8AA0000_00 -0000000001FFFFFF 417FFFFFF0000000_00 -FC00000001FFFFFE C38FFFFFFFF00000_01 -FFFED156A62AB849 C2F2EA959D547B70_00 -0000000000FFFFFF 416FFFFFE0000000_00 -FFFFFFF83FEFFFFD C21F0040000C0000_00 -00015354EAE7C259 42F5354EAE7C2590_00 -00000000007FFFFF 415FFFFFC0000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFF0F4DF3C75 C22E164187160000_00 -00000000003FFFFF 414FFFFF80000000_00 -FFFA000000001FFF C317FFFFFFFF8004_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000001FFFFF 413FFFFF00000000_00 -FFFFFFFFFF7FFE40 C160003800000000_00 -FFFFFFDB5433CB9B C24255E61A328000_00 -00000000000FFFFF 412FFFFE00000000_00 -FFFFFDFFDFFDFFFD C280010010001800_00 -FFFFFFFFFFDEAE1F C140A8F080000000_00 -000000000007FFFF 411FFFFC00000000_00 -FFFFFFFFF0080006 C1AFEFFFF4000000_00 -FFFFFFFE7735DEC7 C1F88CA213900000_00 -000000000003FFFF 410FFFF800000000_00 -00000001FBFFFFFF 41FFBFFFFFF00000_00 -000003757D8B12ED 428BABEC58976800_00 -000000000001FFFF 40FFFFF000000000_00 -FFFFFE07F7FFFFFF C27F808000001000_00 -00000A654064E046 42A4CA80C9C08C00_00 -000000000000FFFF 40EFFFE000000000_00 -08000000000017FF 43A0000000000030_01 -FFFFFFFFFFFFFFE7 C039000000000000_00 -0000000000007FFF 40DFFFC000000000_00 -07FFFFFFFFFFFDF6 439FFFFFFFFFFFF8_01 -FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 -0000000000003FFF 40CFFF8000000000_00 -0000300004000000 42C8000200000000_00 -FFFFFFF70B77F34F C221E91019620000_00 -0000000000001FFF 40BFFF0000000000_00 -FFFFFF80006FFFFE C25FFFE400008000_00 -0000013EB4D67EC8 4273EB4D67EC8000_00 -0000000000000FFF 40AFFE0000000000_00 -BFFFDFFFFBFFFFFF C3D0000800010000_01 -0005CEAF34EA1DC7 43173ABCD3A8771C_00 -00000000000007FF 409FFC0000000000_00 -00004800007FFFFD 42D200001FFFFF40_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000000003FF 408FF80000000000_00 -0000000200001000 4200000080000000_00 -00000000000360D0 410B068000000000_00 -00000000000001FF 407FF00000000000_00 -01003FFFFFFFFFFC 4370040000000000_01 -00C000708FF1BA51 4368000E11FE374B_01 -00000000000000FF 406FE00000000000_00 -F802000003FFFFFF C39FF7FFFFF00000_01 -0F9E07DCC0BDC061 43AF3C0FB9817B81_01 -000000000000007F 405FC00000000000_00 -03FF0000000000FF 438FF80000000008_01 -FFFFFFE1B9B2A079 C23E464D5F870000_00 -000000000000003F 404F800000000000_00 -FFF80000000080FF C31FFFFFFFFDFC04_00 -00000000001EB5B4 413EB5B400000000_00 -000000000000001F 403F000000000000_00 -000000000077FBFE 415DFEFF80000000_00 -00000000005AC607 4156B181C0000000_00 -000000000000000F 402E000000000000_00 -FFFFFFFEF80000FF C1F07FFFF0100000_00 -000005C5B9D66984 429716E759A61000_00 -0000000000000007 401C000000000000_00 -C001FFFFFFF00000 C3CFFF0000000800_00 -00001D06B372AA06 42BD06B372AA0600_00 -0000000000000003 4008000000000000_00 +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFE_01 +0000000032CC8B7A_41C96645BD000000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_C1CFFFE001000000_00 +032C857F319EDE38_4389642BF98CF6F2_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_C29000001FFF0800_00 +00394C79B6D3007B_434CA63CDB69803E_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_C39000003FFFFFF8_01 +0000000001AE458D_417AE458D0000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +F9EB456140D88764_C39852EA7AFC9DE2_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_C2BBFF0000000200_00 +07DE834A248EDF36_439F7A0D28923B7D_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +FFFFFFFFFFE385E2_C13C7A1E00000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_C3AFF7C000000000_01 +000000059EB1FD45_42167AC7F5140000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_C108003800000000_00 +FFFFFFFFFFFEDDFE_C0F2202000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000000C89FF56B_41E913FEAD600000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0_43BB5E4F0BE0DEC0_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_C3003FE000000008_00 +FFFFFFFFFFF4766B_C127132A00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000000C_4028000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +FFE662A109109D0A_C3399D5EF6EF62F6_00 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_C3CFFFFFFFE40000_01 +FFFFFFFFFFFFFFE4_C03C000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_C39FFBFFFFFFC000_00 +FE114B79075F70EE_C37EEB486F8A08F1_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000101_01 +00000000000003AC_408D600000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +00000044A3A3DBE5_425128E8F6F94000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_C33FFFC100000001_00 +FFFFFFFFFFFF1A91_C0ECADE000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_C2A0780000000600_00 +0000000000003309_40C9848000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58_C065000000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_C240FF0000010000_00 +0000000000002980_40C4C00000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +000000000000005D_4057400000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8_C30B9EE12E98A940_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_C3BFFFFFFFFFC000_01 +FFFFFDE3C1DEC43C_C280E1F109DE2000_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_C2EFFFFE80000060_00 +000000000030FFBE_41487FDF00000000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_C2FFFFFF80010030_00 +FFFFFFFFEFDEED86_C1B021127A000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_C3A8000000008000_01 +000000001DA3FF45_41BDA3FF45000000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54_C1F64E434AC00000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +F27DD19DE6563714_C3AB045CC4335391_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_C34FFFFFFFDFFC01_00 +000000000001A359_40FA359000000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +FFFFFFFFFE62EC20_C179D13E00000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000285F_40C42F8000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_C1D00003FC400000_00 +FFFFF836F99DBAA8_C29F241989156000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0033466832042D47_4349A334190216A4_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_C09DE40000000000_00 +00000000003829C8_414C14E400000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000000FB77C672B_422F6EF8CE560000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFC000000_01 +0000000000001B78_40BB780000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_C360000000020400_01 +0000000000000071_405C400000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86_C05E800000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +FFF8A60D9E19F17E_C31D67C987983A08_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +FFFFFFFFF7506DBA_C1A15F248C000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_C0F0409000000000_00 +FFFFFFFFFEA42AC9_C175BD5370000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89_C33855C0D4253377_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9_C3004BF1099291B8_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_C2700001FFF81000_00 +FFFFFFFFFFFFCFBE_C0C8210000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +FEC01FECA24DE1B0_C373FE0135DB21E5_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_C3A0000000400100_01 +F858A66761669936_C39E9D66627A659B_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_C2F007FFFFFFFC20_00 +F716EA43FAC45C97_C3A1D22B780A7746_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_C04D000000000000_00 +0024D70EC7661FD8_43426B8763B30FEC_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_C3CFC00000000000_01 +FFD956DBD0AEE817_C343549217A88BF4_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F80000000_01 +FFFFFFFFFFFF4300_C0E7A00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +C12EDF40F41F6021_C3CF68905F85F04F_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_C35BFFFFFFFFFFF8_01 +FFFFFFF83DE950F6_C21F085ABC280000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_C3DFFFFF00000100_00 +FE2B59CB3A604D69_C37D4A634C59FB29_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFF0_01 +000000A37C210862_42646F84210C4000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +FFFFB65CD8617789_C2D268C9E7A21DC0_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D_C0AFC60000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B0000080000040_01 +000000000D098D19_41AA131A32000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFB0_01 +000006B3BD2C7BEF_429ACEF4B1EFBC00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8_C2E634A444AB6B00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +FFFFFFFFFFFFFF21_C06BE00000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +FFFFFFFFFC648262_C18CDBECF0000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_C3CFFFF000000000_01 +FFFFFF7353AC45D2_C261958A7745C000_00 +8000000000000000_C3E0000000000000_00 +FFFFFFFFFFE7EFFF_C138100100000000_00 +0000000000A1202D_41642405A0000000_00 +C000000000000000_C3D0000000000000_00 +FFFFFFFFFFFF5F7F_C0E4102000000000_00 +000000000040CA70_4150329C00000000_00 +E000000000000000_C3C0000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000003B55D87D4_420DAAEC3EA00000_00 +F000000000000000_C3B0000000000000_00 +FF80000DFFFFFFFF_C35FFFFC80000000_01 +000000010510FAEF_41F0510FAEF00000_00 +F800000000000000_C3A0000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000000724A_40DC928000000000_00 +FC00000000000000_C390000000000000_00 +FFFFFFDF80000002_C2403FFFFFFF0000_00 +0000000000000064_4059000000000000_00 +FE00000000000000_C380000000000000_00 +FEFFFFFFFFF800FE_C370000000007FF0_01 +FFFFFFC2C6222702_C24E9CEEEC7F0000_00 +FF00000000000000_C370000000000000_00 +0000000408000002_4210200000080000_00 +000000E96DF1CB41_426D2DBE39682000_00 +FF80000000000000_C360000000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE80_01 +F727F174DEE7DC85_C3A1B01D16423046_01 +FFC0000000000000_C350000000000000_00 +8000000003FFFEFE_C3DFFFFFFFFF0000_01 +FFFFFFFFFFF0BD5B_C12E854A00000000_00 +FFE0000000000000_C340000000000000_00 +0BEFFFFFFFFFFFFF_43A7E00000000000_01 +000000000002790C_4103C86000000000_00 +FFF0000000000000_C330000000000000_00 +FFFFFFFFFFEFFBFA_C130040600000000_00 +000000169E75DF01_42369E75DF010000_00 +FFF8000000000000_C320000000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000000E_402C000000000000_00 +FFFC000000000000_C310000000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +FFFFFFFFFFF28622_C12AF3BC00000000_00 +FFFE000000000000_C300000000000000_00 +FFFFFF7FFFFDF7FF_C260000041002000_00 +00072F0EC496FE21_431CBC3B125BF884_00 +FFFF000000000000_C2F0000000000000_00 +DFBFFFFFFFFFFFFE_C3C0200000000000_01 +0000000000FC1FCA_416F83F940000000_00 +FFFF800000000000_C2E0000000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE_C2E5CD636AC7A640_00 +FFFFC00000000000_C2D0000000000000_00 +00000002100007FD_420080003FE80000_00 +FFFFFFFFFFC2D8FE_C14E938100000000_00 +FFFFE00000000000_C2C0000000000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000001766E_40F766E000000000_00 +FFFFF00000000000_C2B0000000000000_00 +0040000400000002_4350000100000001_01 +0000000000007841_40DE104000000000_00 +FFFFF80000000000_C2A0000000000000_00 +3DFFFFFFFFFFFF7E_43CF000000000000_01 +FFFFFFE549E17E30_C23AB61E81D00000_00 +FFFFFC0000000000_C290000000000000_00 +FFFFFFFFFFFFFEE1_C071F00000000000_00 +FFFFFFFFFFFFFFE7_C039000000000000_00 +FFFFFE0000000000_C280000000000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73_C061A00000000000_00 +FFFFFF0000000000_C270000000000000_00 +FD00000008000000_C387FFFFFFC00000_00 +000000000001DBB1_40FDBB1000000000_00 +FFFFFF8000000000_C260000000000000_00 +FFFFFFFFFFF8007F_C11FFE0400000000_00 +FFFFFFFEFD10A515_C1F02EF5AEB00000_00 +FFFFFFC000000000_C250000000000000_00 +FFEFFFFFFFFFFFFE_C330000000000002_00 +FAB02984F6283B6C_C3953F59EC275F12_01 +FFFFFFE000000000_C240000000000000_00 +FFFFFFBC000001FE_C250FFFFFF808000_00 +FEB087C6B9FE7FE0_C374F78394601802_00 +FFFFFFF000000000_C230000000000000_00 +FFF80001000007FE_C31FFFFBFFFFE008_00 +00F2762EA6837956_436E4EC5D4D06F2B_01 +FFFFFFF800000000_C220000000000000_00 +FFF7E0FFFFFFFFFE_C3203E0000000004_00 +00002E1175484626_42C708BAA4231300_00 +FFFFFFFC00000000_C210000000000000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000068F_409A3C0000000000_00 +FFFFFFFE00000000_C200000000000000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFE000_01 +FFFFFFFFFFFFFFF9_C01C000000000000_00 +FFFFFFFF00000000_C1F0000000000000_00 +FFFFFFD0000FFFFD_C247FFF800018000_00 +000000BDF6658B83_4267BECCB1706000_00 +FFFFFFFF80000000_C1E0000000000000_00 +1000001FFDFFFFFF_43B000001FFE0000_01 +0000000000003B5B_40CDAD8000000000_00 +FFFFFFFFC0000000_C1D0000000000000_00 +FFFFFFBFFE0FFFFF_C250007C00004000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +FFFFFFFFE0000000_C1C0000000000000_00 +FFFFFFFBF00007FF_C2103FFFE0040000_00 +01E986274F48EAAD_437E986274F48EAB_01 +FFFFFFFFF0000000_C1B0000000000000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFE000000_01 +FFFFFFFFFFFFCB5A_C0CA530000000000_00 +FFFFFFFFF8000000_C1A0000000000000_00 +7FF000000000FFFF_43DFFC0000000040_01 +00000003C2717FC3_420E138BFE180000_00 +FFFFFFFFFC000000_C190000000000000_00 +FFFFFFE00008001F_C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA_C130542600000000_00 +FFFFFFFFFE000000_C180000000000000_00 +0200000000000002_4380000000000001_01 +FFFFFFFFF8FDA53F_C19C096B04000000_00 +FFFFFFFFFF000000_C170000000000000_00 +F6000003FFFFFFFE_C3A3FFFFF8000000_01 +FFFFFFFFFFFFFFD0_C048000000000000_00 +FFFFFFFFFF800000_C160000000000000_00 +FFFFFFFFFFBFFF7E_C150002080000000_00 +00000000EE0FEA62_41EDC1FD4C400000_00 +FFFFFFFFFFC00000_C150000000000000_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000037F35EDC1D_424BF9AF6E0E8000_00 +FFFFFFFFFFE00000_C140000000000000_00 +FFFFFFF7FDFFFF7D_C220040001060000_00 +00000000000001AD_407AD00000000000_00 +FFFFFFFFFFF00000_C130000000000000_00 +FFFFFF0000100020_C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A_43C3F8B3FDE3FE30_01 +FFFFFFFFFFF80000_C120000000000000_00 +003FFFFFFFFC0001_434FFFFFFFFE0001_01 +000E48F9F4EBD30E_432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000_C110000000000000_00 +DFFFFFFFFFFBFFFE_C3C0000000000200_01 +FC91C23EE8C9424F_C38B71EE08B9B5ED_01 +FFFFFFFFFFFE0000_C100000000000000_00 +F7DFFBFFFFFFFFFE_C3A0400800000000_01 +000000002CAE080C_41C6570406000000_00 +FFFFFFFFFFFF0000_C0F0000000000000_00 +FFFFC00010000020_C2CFFFF7FFFFF000_00 +04D921F917B20E40_43936487E45EC839_00 +FFFFFFFFFFFF8000_C0E0000000000000_00 +F8000FFFFFFFFFFD_C39FFFC000000000_01 +FFF17C566BC7D811_C32D075328704FDE_00 +FFFFFFFFFFFFC000_C0D0000000000000_00 +00000000000000FE_406FC00000000000_00 +FFF82AC14930D386_C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000_C0C0000000000000_00 +00000000000003FC_408FE00000000000_00 +000E62EC60E119FC_432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000_C0B0000000000000_00 +FFFFEFF7FF7FFFFE_C2B0080080000200_00 +0E2B1ECF210EEDC5_43AC563D9E421DDC_01 +FFFFFFFFFFFFF800_C0A0000000000000_00 +00000000007FFF1F_415FFFC7C0000000_00 +FFFFFE534F5676F7_C27ACB0A98909000_00 +FFFFFFFFFFFFFC00_C090000000000000_00 +0000001004FFFFFD_423004FFFFFD0000_00 +0000035C939669F1_428AE49CB34F8800_00 +FFFFFFFFFFFFFE00_C080000000000000_00 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFE_01 +FFFFFFFFFFFFFF91_C05BC00000000000_00 +FFFFFFFFFFFFFF00_C070000000000000_00 +01FFFFFFFBFFEFFE_437FFFFFFFBFFF00_01 +000000000000016E_4076E00000000000_00 +FFFFFFFFFFFFFF80_C060000000000000_00 +FFF7FFFFFFFFF7FD_C320000000001006_00 +FFFFF8E2BCFAC553_C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0_C050000000000000_00 +FFFFFBFFFFFE0FFE_C290000007C00800_00 +00000001A4E704BF_41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0_C040000000000000_00 +1400007FFFFFFFFD_43B4000080000000_01 +FFFFFFFC93B187B4_C20B6273C2600000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +40000000007FFFFD_43D0000000002000_01 +000000000067D468_4159F51A00000000_00 +FFFFFFFFFFFFFFF8_C020000000000000_00 +007FFEFFFFFBFFFE_435FFFBFFFFF0000_01 +FFFFFFE26CEC79F8_C23D931386080000_00 +FFFFFFFFFFFFFFFC_C010000000000000_00 +00FFFFFF000000FF_436FFFFFE0000020_01 +FFFFFFFFE0D3983A_C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE_C000000000000000_00 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A_C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF_BFF0000000000000_00 +000008000000027E_42A000000004FC00_00 +000000000000F4E8_40EE9D0000000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFF83FFDF_C15F000840000000_00 +00000E11407887B2_42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +04000003FFFFFFF6_4390000010000000_01 +0000000000000513_40944C0000000000_00 +FFFFFFFFFFFFFFF7_C022000000000000_00 +BFFC00000000003E_C3D000FFFFFFFFFF_01 +00000008D7BBB75B_4221AF776EB60000_00 +FFFFFFFFFFFFFFEF_C031000000000000_00 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23_C14952EE80000000_00 +FFFFFFFFFFFFFFDF_C040800000000000_00 +FFBFDFFFBFFFFFFF_C350080010000000_01 +000000000000007F_405FC00000000000_00 +FFFFFFFFFFFFFFBF_C050400000000000_00 +00000007FF800003_421FFE00000C0000_00 +000000000002BB02_4105D81000000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEE7FF_C0F1801000000000_00 +00264B2B9BAD0DA2_43432595CDD686D1_00 +FFFFFFFFFFFFFEFF_C070100000000000_00 +0000000000100803_4130080300000000_00 +FF9B1DCB9F857D5E_C359388D181EA0A8_01 +FFFFFFFFFFFFFDFF_C080080000000000_00 +FFFFFFBFFFFFEFEE_C250000004048000_00 +F6FD7542899C1C6F_C3A205157AECC7C7_01 +FFFFFFFFFFFFFBFF_C090040000000000_00 +FF800000004001FF_C35FFFFFFFEFFF80_01 +0000000002BE4932_4185F24990000000_00 +FFFFFFFFFFFFF7FF_C0A0020000000000_00 +00001004000FFFFE_42B004000FFFFE00_00 +FFFFFF9DAA0123E0_C258957FB7080000_00 +FFFFFFFFFFFFEFFF_C0B0010000000000_00 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0_C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF_C0C0008000000000_00 +FE0FE00000000000_C37F020000000000_00 +0779ED944A4E2779_439DE7B65129389E_01 +FFFFFFFFFFFFBFFF_C0D0004000000000_00 +FBFFFE0400000000_C3900007F0000000_00 +0000010127E03666_4270127E03666000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +FFFFF0200000FFFE_C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEFFFF_C0F0001000000000_00 +FFEFFE0000080000_C33001FFFFF80000_00 +FFFFFFFFFD3354EA_C1866558B0000000_00 +FFFFFFFFFFFDFFFF_C100000800000000_00 +003FF0000003FFFE_434FF8000001FFFF_00 +0000006375B23F7B_4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF_C110000400000000_00 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000092117F38_41E2422FE7000000_00 +FFFFFFFFFFF7FFFF_C120000200000000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +00000000000008BE_40A17C0000000000_00 +FFFFFFFFFFEFFFFF_C130000100000000_00 +004000020FFFFFFF_4350000084000000_01 +FFFFB84C2D8BC9CB_C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF_C140000080000000_00 +00FFFFFFFFFFFFFD_4370000000000000_01 +00000023C2C6F284_4241E16379420000_00 +FFFFFFFFFFBFFFFF_C150000040000000_00 +FFFDDFFFFFFFFFFD_C301000000000018_00 +00000000746356C4_41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF_C160000020000000_00 +010000000000BFFF_4370000000000C00_01 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFEFFFFFF_C170000010000000_00 +FFFFBF7FFBFFFFFE_C2D0200100000080_00 +00000006386CE889_4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF_C180000008000000_00 +F00000F7FFFFFFFF_C3AFFFFE10000000_01 +FFFDFC53090C46A4_C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +0000000000800047_41600008E0000000_00 +FFFFFFFFD693872E_C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF_C1A0000002000000_00 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000026A7845E35_424353C22F1A8000_00 +FFFFFFFFEFFFFFFF_C1B0000001000000_00 +FFFFFFDFFFFFFBFD_C240000002018000_00 +000000001433D14C_41B433D14C000000_00 +FFFFFFFFDFFFFFFF_C1C0000000800000_00 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +F0F23E8068D3D84A_C3AE1B82FF2E584F_01 +FFFFFFFFBFFFFFFF_C1D0000000400000_00 +F7FFBFFFFFFFBFFF_C3A0008000000080_01 +FFFFBD29B7459087_C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF_C1E0000000200000_00 +FFFFFFF8FFFFBFFF_C21C000100040000_00 +FFFFFFFFFFEDDC06_C13223FA00000000_00 +FFFFFFFEFFFFFFFF_C1F0000000100000_00 +FFFFFFF80001FFFF_C21FFFF800040000_00 +0000000000002FF9_40C7FC8000000000_00 +FFFFFFFDFFFFFFFF_C200000000080000_00 +004000040000FFFF_4350000100004000_01 +FFFFFFFFFFFFFFF1_C02E000000000000_00 +FFFFFFFBFFFFFFFF_C210000000040000_00 +C0000000007FFFFA_C3CFFFFFFFFFC000_01 +FFFFFFFFFE053E2B_C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF_C220000000020000_00 +7FFE000007FFFFFF_43DFFF8000020000_01 +000000000000000D_402A000000000000_00 +FFFFFFEFFFFFFFFF_C230000000010000_00 +F80000000001007E_C39FFFFFFFFFFBFE_01 +FFFFED48424AD9D6_C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF_C240000000008000_00 +FFFFFE0001FEFFFF_C27FFFE010001000_00 +000000000000013B_4073B00000000000_00 +FFFFFFBFFFFFFFFF_C250000000004000_00 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0244_01 +FFFFFF7FFFFFFFFF_C260000000002000_00 +00FFF7FFFF7FFFFE_436FFEFFFFF00000_01 +0000000000000006_4018000000000000_00 +FFFFFEFFFFFFFFFF_C270000000001000_00 +FBFFFFBFFFBFFFFF_C390000100010000_01 +00000000000001BA_407BA00000000000_00 +FFFFFDFFFFFFFFFF_C280000000000800_00 +0000000040000082_41D0000020800000_00 +FF07A2BF5B689F89_C36F0BA81492EC0E_01 +FFFFFBFFFFFFFFFF_C290000000000400_00 +0000001FF8000008_423FF80000080000_00 +F87CAA7DE672DE8B_C39E0D5608663485_01 +FFFFF7FFFFFFFFFF_C2A0000000000200_00 +07FFF80000000002_439FFFE000000001_01 +0000000010A1E5B8_41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF_C2B0000000000100_00 +F7FFFFE00007FFFF_C3A000003FFFF000_01 +FFFFFFFFFFF6ADFC_C122A40800000000_00 +FFFFDFFFFFFFFFFF_C2C0000000000080_00 +FFFFFF03FFFFFFC0_C26F800000080000_00 +EA579475948F0032_C3B5A86B8A6B70FF_01 +FFFFBFFFFFFFFFFF_C2D0000000000040_00 +FC00000000003FF6_C38FFFFFFFFFFE00_01 +002E677AC313BF60_434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF_C2E0000000000020_00 +02000007FF7FFFFF_438000003FFC0000_01 +0000000E999639F1_422D332C73E20000_00 +FFFEFFFFFFFFFFFF_C2F0000000000010_00 +FFFF83FFFFFFFFBE_C2DF000000001080_00 +000000000001537D_40F537D000000000_00 +FFFDFFFFFFFFFFFF_C300000000000008_00 +EFFFFFC00000003D_C3B000003FFFFFFF_01 +FFFFFFF21FEDFD35_C22BC02405960000_00 +FFFBFFFFFFFFFFFF_C310000000000004_00 +FFFFFFF0000007FE_C22FFFFFF0040000_00 +FFFFFFFFFFDE0839_C140FBE380000000_00 +FFF7FFFFFFFFFFFF_C320000000000002_00 +0000007FFFE000FF_425FFFF8003FC000_00 +FFFFFFFF79F30F48_C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF_C330000000000001_00 +FFFFFC13FFFFFFFD_C28F600000001800_00 +0000000000001B85_40BB850000000000_00 +FFDFFFFFFFFFFFFF_C340000000000000_01 +000008000007FFFE_42A000000FFFFC00_00 +12DB4409E5AE87E6_43B2DB4409E5AE88_01 +FFBFFFFFFFFFFFFF_C350000000000000_01 +FFFFFFFFFFF7BFEE_C120802400000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FF7FFFFFFFFFFFFF_C360000000000000_01 +000000001040FFFE_41B040FFFE000000_00 +00000909A09C13D3_42A213413827A600_00 +FEFFFFFFFFFFFFFF_C370000000000000_01 +FFFFFF01FFFFFF7F_C26FC00000102000_00 +FFFFFF72E7D2575D_C261A305B5146000_00 +FDFFFFFFFFFFFFFF_C380000000000000_01 +FFFFFFFFFFFEFFDB_C0F0025000000000_00 +0000000000000017_4037000000000000_00 +FBFFFFFFFFFFFFFF_C390000000000000_01 +100000001FFFFFF6_43B0000000200000_01 +000000114B12EF51_42314B12EF510000_00 +F7FFFFFFFFFFFFFF_C3A0000000000000_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFC_01 +FFFFFF769F3A5C2C_C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF_C3B0000000000000_01 +FFFFFFFDF7FFFFFD_C200400000180000_00 +FFFFFFFFFFFFFFF2_C02C000000000000_00 +DFFFFFFFFFFFFFFF_C3C0000000000000_01 +FFFFFFFFFE0007FF_C17FFF8010000000_00 +000000000000001E_403E000000000000_00 +BFFFFFFFFFFFFFFF_C3D0000000000000_01 +FFF800000009FFFF_C31FFFFFFFD80004_00 +0000000000007AA4_40DEA90000000000_00 +7FFFFFFFFFFFFFFF_43E0000000000000_01 +4080000000FFFFFF_43D0200000004000_01 +000000000DE7601D_41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF_43D0000000000000_01 +FFCFFFFFFFBFFFFE_C348000000200001_00 +FFFFFFFFFFFFFFCA_C04B000000000000_00 +1FFFFFFFFFFFFFFF_43C0000000000000_01 +000080400000003F_42E00800000007E0_00 +00000000001F75A5_413F75A500000000_00 +0FFFFFFFFFFFFFFF_43B0000000000000_01 +FFFFFFEFFFFFCFFE_C230000030020000_00 +FFFFFEE775887420_C27188A778BE0000_00 +07FFFFFFFFFFFFFF_43A0000000000000_01 +00000000000801FE_412003FC00000000_00 +0000000000213FF1_41409FF880000000_00 +03FFFFFFFFFFFFFF_4390000000000000_01 +07FEFFFFFFFFFFEE_439FFC0000000000_01 +0000000000000004_4010000000000000_00 +01FFFFFFFFFFFFFF_4380000000000000_01 +0000000820000003_4220400000060000_00 +FFFFFFF9AD105214_C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF_4370000000000000_01 +FFFFF00FFFFFFFBE_C2AFE00000008400_00 +FFFFFFFFFFCC48E7_C149DB8C80000000_00 +007FFFFFFFFFFFFF_4360000000000000_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB_C16E8B26A0000000_00 +003FFFFFFFFFFFFF_4350000000000000_01 +FFFFFF7FBFFFFFBF_C260080000082000_00 +FFFFFFFFFFF24425_C12B77B600000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFE00_01 +FFFFFF4E7115EC53_C26631DD4275A000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_C29FF00000010400_00 +FFFFFC2E539ADCFE_C28E8D6329181000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +00000055084732F3_42554211CCBCC000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_C3D0002000000000_01 +FFFFFFFFFFFF8543_C0DEAF4000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +FFFFFFFFFFFE491B_C0FB6E5000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_C38FFEFFFFFFFF00_01 +FFFFF16898822A24_C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF8200000000_01 +FFFFFF8FFE18C7BF_C25C0079CE104000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_C270001000003000_00 +00F03620C1266ED9_436E06C41824CDDC_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_C3D0204000000000_01 +FFFFFFFFFFFFFFD5_C045800000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_C31000001FF00008_00 +0000000000068684_411A1A1000000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_C3C000000FFFFFFF_01 +FFFFFFFFFFFFECF5_C0B30B0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_C2EFF7FFFFE00020_00 +0000000000000002_4000000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_C390000000000108_01 +0000000000000BC9_40A7920000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_C3DFE00000000008_01 +FFC274E35A70CD76_C34EC58E52C79945_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFE0000_01 +FFFFFFFF00E73AFC_C1EFE318A0800000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9_C0FEA17000000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +0000000000000033_4049800000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +FFFFFFEE6B141E1B_C23194EBE1E50000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_C1A3FFF002000000_00 +00000001AB310BA6_41FAB310BA600000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195_C0ACD60000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_C1DFFFFFFD400000_00 +00000019BA8D5559_4239BA8D55590000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_C390040000000000_01 +FFFFFFB6F062822D_C25243E75F74C000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +01CEAD9E2FB104A4_437CEAD9E2FB104B_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +FFFFFFFFFD681E78_C184BF0C40000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000018_4038000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000001_01 +FFFFFFFFFFFFFF95_C05AC00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000C00000000_01 +0000001697087B19_423697087B190000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_C390000000004400_01 +0000000E64BDFC55_422CC97BF8AA0000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_C38FFFFFFFF00000_01 +FFFED156A62AB849_C2F2EA959D547B70_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_C21F0040000C0000_00 +00015354EAE7C259_42F5354EAE7C2590_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFF0F4DF3C75_C22E164187160000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_C160003800000000_00 +FFFFFFDB5433CB9B_C24255E61A328000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_C280010010001800_00 +FFFFFFFFFFDEAE1F_C140A8F080000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7_C1F88CA213900000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000003757D8B12ED_428BABEC58976800_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_C27F808000001000_00 +00000A654064E046_42A4CA80C9C08C00_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A0000000000030_01 +FFFFFFFFFFFFFFE7_C039000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF8_01 +FFFFAD78B3D6C3B6_C2D4A1D30A4F1280_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +FFFFFFF70B77F34F_C221E91019620000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_C25FFFE400008000_00 +0000013EB4D67EC8_4273EB4D67EC8000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_C3D0000800010000_01 +0005CEAF34EA1DC7_43173ABCD3A8771C_00 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000360D0_410B068000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_4370040000000000_01 +00C000708FF1BA51_4368000E11FE374B_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_C39FF7FFFFF00000_01 +0F9E07DCC0BDC061_43AF3C0FB9817B81_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000008_01 +FFFFFFE1B9B2A079_C23E464D5F870000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_C31FFFFFFFFDFC04_00 +00000000001EB5B4_413EB5B400000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +00000000005AC607_4156B181C0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_C1F07FFFF0100000_00 +000005C5B9D66984_429716E759A61000_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_C3CFFF0000000800_00 +00001D06B372AA06_42BD06B372AA0600_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/i64_f64_rz.tv b/wally-pipelined/testbench/fp/i64_f64_rz.tv index 315fa3fe4..51b16c1bb 100644 --- a/wally-pipelined/testbench/fp/i64_f64_rz.tv +++ b/wally-pipelined/testbench/fp/i64_f64_rz.tv @@ -1,756 +1,756 @@ -07FFFDFFFFFFFF7F 439FFFF7FFFFFFFD_01 -0000000032CC8B7A 41C96645BD000000_00 -0000000000000000 0000000000000000_00 -FFFFFFFFC0003FFE C1CFFFE001000000_00 -032C857F319EDE38 4389642BF98CF6F1_01 -0000000000000001 3FF0000000000000_00 -FFFFFBFFFFF8003E C29000001FFF0800_00 -00394C79B6D3007B 434CA63CDB69803D_01 -0000000000000002 4000000000000000_00 -FBFFFFF0000001FF C39000003FFFFFF8_01 -0000000001AE458D 417AE458D0000000_00 -0000000000000004 4010000000000000_00 -00040008000007FE 4310002000001FF8_00 -F9EB456140D88764 C39852EA7AFC9DE2_01 -0000000000000008 4020000000000000_00 -FFFFE400FFFFFFFE C2BBFF0000000200_00 -07DE834A248EDF36 439F7A0D28923B7C_01 -0000000000000010 4030000000000000_00 -00000003FF001FFF 420FF800FFF80000_00 -FFFFFFFFFFE385E2 C13C7A1E00000000_00 -0000000000000020 4040000000000000_00 -F0041FFFFFFFFFFF C3AFF7C000000000_01 -000000059EB1FD45 42167AC7F5140000_00 -0000000000000040 4050000000000000_00 -FFFFFFFFFFFCFFF9 C108003800000000_00 -FFFFFFFFFFFEDDFE C0F2202000000000_00 -0000000000000080 4060000000000000_00 -000000000003FF00 410FF80000000000_00 -00000000C89FF56B 41E913FEAD600000_00 -0000000000000100 4070000000000000_00 -000FFFFF7FDFFFFF 432FFFFEFFBFFFFE_00 -1B5E4F0BE0DEBFF0 43BB5E4F0BE0DEBF_01 -0000000000000200 4080000000000000_00 -FFFDF803FFFFFFFF C3003FE000000008_00 -FFFFFFFFFFF4766B C127132A00000000_00 -0000000000000400 4090000000000000_00 -0000080100000FFE 42A00200001FFC00_00 -000000000000000C 4028000000000000_00 -0000000000000800 40A0000000000000_00 -0048000000100000 4352000000040000_00 -FFE662A109109D0A C3399D5EF6EF62F6_00 -0000000000001000 40B0000000000000_00 -C000000037FFFFFE C3CFFFFFFFE40000_01 -FFFFFFFFFFFFFFE4 C03C000000000000_00 -0000000000002000 40C0000000000000_00 -F801000000100000 C39FFBFFFFFFC000_00 -FE114B79075F70EE C37EEB486F8A08F1_01 -0000000000004000 40D0000000000000_00 -100000000001003E 43B0000000000100_01 -00000000000003AC 408D600000000000_00 -0000000000008000 40E0000000000000_00 -200000FFFFFFF800 43C000007FFFFFFC_00 -00000044A3A3DBE5 425128E8F6F94000_00 -0000000000010000 40F0000000000000_00 -FFE0003EFFFFFFFF C33FFFC100000001_00 -FFFFFFFFFFFF1A91 C0ECADE000000000_00 -0000000000020000 4100000000000000_00 -FFFFF7C3FFFFFFFD C2A0780000000600_00 -0000000000003309 40C9848000000000_00 -0000000000040000 4110000000000000_00 -000083FFF7FFFFFE 42E07FFEFFFFFFC0_00 -FFFFFFFFFFFFFF58 C065000000000000_00 -0000000000080000 4120000000000000_00 -FFFFFFDE01FFFFFE C240FF0000010000_00 -0000000000002980 40C4C00000000000_00 -0000000000100000 4130000000000000_00 -00000000FFF07FFF 41EFFE0FFFE00000_00 -000000000000005D 4057400000000000_00 -0000000000200000 4140000000000000_00 -000020FFDFFFFFFF 42C07FEFFFFFFF80_00 -FFFC8C23DA2CEAD8 C30B9EE12E98A940_00 -0000000000400000 4150000000000000_00 -E0000000003FFFDF C3BFFFFFFFFFC000_01 -FFFFFDE3C1DEC43C C280E1F109DE2000_00 -0000000000800000 4160000000000000_00 -FFFF00000BFFFFFD C2EFFFFE80000060_00 -000000000030FFBE 41487FDF00000000_00 -0000000001000000 4170000000000000_00 -FFFE000007FFEFFD C2FFFFFF80010030_00 -FFFFFFFFEFDEED86 C1B021127A000000_00 -0000000002000000 4180000000000000_00 -F3FFFFFFFFBFFFFE C3A8000000008000_01 -000000001DA3FF45 41BDA3FF45000000_00 -0000000004000000 4190000000000000_00 -FFFFFFFF00010007 C1EFFFDFFF200000_00 -FFFFFFFE9B1BCB54 C1F64E434AC00000_00 -0000000008000000 41A0000000000000_00 -00004000004001FE 42D0000010007F80_00 -F27DD19DE6563714 C3AB045CC4335391_01 -0000000010000000 41B0000000000000_00 -FFC00000004007FE C34FFFFFFFDFFC01_00 -000000000001A359 40FA359000000000_00 -0000000020000000 41C0000000000000_00 -0000000003C000FE 418E0007F0000000_00 -FFFFFFFFFE62EC20 C179D13E00000000_00 -0000000040000000 41D0000000000000_00 -000000003FFFFFFD 41CFFFFFFE800000_00 -000000000000285F 40C42F8000000000_00 -0000000080000000 41E0000000000000_00 -FFFFFFFFBFFFF00F C1D00003FC400000_00 -FFFFF836F99DBAA8 C29F241989156000_00 -0000000100000000 41F0000000000000_00 -00000020003FFEFE 4240001FFF7F0000_00 -0033466832042D47 4349A334190216A3_01 -0000000200000000 4200000000000000_00 -FFFFFFFFFFFFF887 C09DE40000000000_00 -00000000003829C8 414C14E400000000_00 -0000000400000000 4210000000000000_00 -00000FFFFFFF7DFD 42AFFFFFFEFBFA00_00 -0000000FB77C672B 422F6EF8CE560000_00 -0000000800000000 4220000000000000_00 -08003FFDFFFFFFFE 43A0007FFBFFFFFF_01 -0000000000001B78 40BB780000000000_00 -0000001000000000 4230000000000000_00 -FF7FFFFFFFEFDFFF C360000000020400_01 -0000000000000071 405C400000000000_00 -0000002000000000 4240000000000000_00 -000013FFFFFFFDFF 42B3FFFFFFFDFF00_00 -FFFFFFFFFFFFFF86 C05E800000000000_00 -0000004000000000 4250000000000000_00 -0800000000040800 43A0000000000810_00 -FFF8A60D9E19F17E C31D67C987983A08_00 -0000008000000000 4260000000000000_00 -000077FFF0000000 42DDFFFC00000000_00 -FFFFFFFFF7506DBA C1A15F248C000000_00 -0000010000000000 4270000000000000_00 -FFFFFFFFFFFEFBF7 C0F0409000000000_00 -FFFFFFFFFEA42AC9 C175BD5370000000_00 -0000020000000000 4280000000000000_00 -0000107FFFFFDFFD 42B07FFFFFDFFD00_00 -FFE7AA3F2BDACC89 C33855C0D4253377_00 -0000040000000000 4290000000000000_00 -FFF8040000040000 C31FEFFFFFF00000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -0000080000000000 42A0000000000000_00 -FFFF80000800001F C2DFFFFDFFFFF840_00 -FFFDF681DECDADC9 C3004BF1099291B8_00 -0000100000000000 42B0000000000000_00 -FFFFFEFFFFE0007F C2700001FFF81000_00 -FFFFFFFFFFFFCFBE C0C8210000000000_00 -0000200000000000 42C0000000000000_00 -0000000901FFFFFD 422203FFFFFA0000_00 -FEC01FECA24DE1B0 C373FE0135DB21E5_00 -0000400000000000 42D0000000000000_00 -F7FFFFFFDFFF7FFF C3A0000000400100_01 -F858A66761669936 C39E9D66627A659B_01 -0000800000000000 42E0000000000000_00 -FFFEFF800000003E C2F007FFFFFFFC20_00 -F716EA43FAC45C97 C3A1D22B780A7746_01 -0001000000000000 42F0000000000000_00 -FFFFFFFFFFFFFFC6 C04D000000000000_00 -0024D70EC7661FD8 43426B8763B30FEC_00 -0002000000000000 4300000000000000_00 -C07FFFFFFFFFFFFE C3CFC00000000000_01 -FFD956DBD0AEE817 C343549217A88BF4_01 -0004000000000000 4310000000000000_00 -020003EFFFFFFFFE 4380001F7FFFFFFF_01 -FFFFFFFFFFFF4300 C0E7A00000000000_00 -0008000000000000 4320000000000000_00 -4000000004002000 43D0000000010008_00 -C12EDF40F41F6021 C3CF68905F85F04F_01 -0010000000000000 4330000000000000_00 -FF9000000000001D C35BFFFFFFFFFFF8_01 -FFFFFFF83DE950F6 C21F085ABC280000_00 -0020000000000000 4340000000000000_00 -800003FFFFFC0000 C3DFFFFF00000100_00 -FE2B59CB3A604D69 C37D4A634C59FB29_01 -0040000000000000 4350000000000000_00 -7FFFFFFDFFFFBFFF 43DFFFFFFF7FFFEF_01 -000000A37C210862 42646F84210C4000_00 -0080000000000000 4360000000000000_00 -0002000002000002 4300000010000010_00 -FFFFB65CD8617789 C2D268C9E7A21DC0_00 -0100000000000000 4370000000000000_00 -00001BFFFFFFBFFE 42BBFFFFFFBFFE00_00 -FFFFFFFFFFFFF01D C0AFC60000000000_00 -0200000000000000 4380000000000000_00 -1000008000003FFF 43B000008000003F_01 -000000000D098D19 41AA131A32000000_00 -0400000000000000 4390000000000000_00 -03FFFFFFFFFFF5FF 438FFFFFFFFFFFAF_01 -000006B3BD2C7BEF 429ACEF4B1EFBC00_00 -0800000000000000 43A0000000000000_00 -00003FFFBFFFFFFE 42CFFFDFFFFFFF00_00 -FFFF4E5ADDDAA4A8 C2E634A444AB6B00_00 -1000000000000000 43B0000000000000_00 -001FFFC000000FFD 433FFFC000000FFD_00 -FFFFFFFFFFFFFF21 C06BE00000000000_00 -2000000000000000 43C0000000000000_00 -0000000041DFFFFF 41D077FFFFC00000_00 -FFFFFFFFFC648262 C18CDBECF0000000_00 -4000000000000000 43D0000000000000_00 -C0001FFFFFFFFFFB C3CFFFF000000000_01 -FFFFFF7353AC45D2 C261958A7745C000_00 -8000000000000000 C3E0000000000000_00 -FFFFFFFFFFE7EFFF C138100100000000_00 -0000000000A1202D 41642405A0000000_00 -C000000000000000 C3D0000000000000_00 -FFFFFFFFFFFF5F7F C0E4102000000000_00 -000000000040CA70 4150329C00000000_00 -E000000000000000 C3C0000000000000_00 -0000200201FFFFFE 42C00100FFFFFF00_00 -00000003B55D87D4 420DAAEC3EA00000_00 -F000000000000000 C3B0000000000000_00 -FF80000DFFFFFFFF C35FFFFC80000000_01 -000000010510FAEF 41F0510FAEF00000_00 -F800000000000000 C3A0000000000000_00 -0003FFF00000000F 430FFF8000000078_00 -000000000000724A 40DC928000000000_00 -FC00000000000000 C390000000000000_00 -FFFFFFDF80000002 C2403FFFFFFF0000_00 -0000000000000064 4059000000000000_00 -FE00000000000000 C380000000000000_00 -FEFFFFFFFFF800FE C370000000007FF0_01 -FFFFFFC2C6222702 C24E9CEEEC7F0000_00 -FF00000000000000 C370000000000000_00 -0000000408000002 4210200000080000_00 -000000E96DF1CB41 426D2DBE39682000_00 -FF80000000000000 C360000000000000_00 -007FFFFFFFFFF9FE 435FFFFFFFFFFE7F_01 -F727F174DEE7DC85 C3A1B01D16423046_01 -FFC0000000000000 C350000000000000_00 -8000000003FFFEFE C3DFFFFFFFFF0000_01 -FFFFFFFFFFF0BD5B C12E854A00000000_00 -FFE0000000000000 C340000000000000_00 -0BEFFFFFFFFFFFFF 43A7DFFFFFFFFFFF_01 -000000000002790C 4103C86000000000_00 -FFF0000000000000 C330000000000000_00 -FFFFFFFFFFEFFBFA C130040600000000_00 -000000169E75DF01 42369E75DF010000_00 -FFF8000000000000 C320000000000000_00 -00000007FEFFDFFF 421FFBFF7FFC0000_00 -000000000000000E 402C000000000000_00 -FFFC000000000000 C310000000000000_00 -0003FFFE0007FFFE 430FFFF0003FFFF0_00 -FFFFFFFFFFF28622 C12AF3BC00000000_00 -FFFE000000000000 C300000000000000_00 -FFFFFF7FFFFDF7FF C260000041002000_00 -00072F0EC496FE21 431CBC3B125BF884_00 -FFFF000000000000 C2F0000000000000_00 -DFBFFFFFFFFFFFFE C3C0200000000000_01 -0000000000FC1FCA 416F83F940000000_00 -FFFF800000000000 C2E0000000000000_00 -00000FFF800FFFFE 42AFFF001FFFFC00_00 -FFFF5194E4A9C2CE C2E5CD636AC7A640_00 -FFFFC00000000000 C2D0000000000000_00 -00000002100007FD 420080003FE80000_00 -FFFFFFFFFFC2D8FE C14E938100000000_00 -FFFFE00000000000 C2C0000000000000_00 -000000000007FF6E 411FFDB800000000_00 -000000000001766E 40F766E000000000_00 -FFFFF00000000000 C2B0000000000000_00 -0040000400000002 4350000100000000_01 -0000000000007841 40DE104000000000_00 -FFFFF80000000000 C2A0000000000000_00 -3DFFFFFFFFFFFF7E 43CEFFFFFFFFFFFF_01 -FFFFFFE549E17E30 C23AB61E81D00000_00 -FFFFFC0000000000 C290000000000000_00 -FFFFFFFFFFFFFEE1 C071F00000000000_00 -FFFFFFFFFFFFFFE7 C039000000000000_00 -FFFFFE0000000000 C280000000000000_00 -000000000EFFFFDF 41ADFFFFBE000000_00 -FFFFFFFFFFFFFF73 C061A00000000000_00 -FFFFFF0000000000 C270000000000000_00 -FD00000008000000 C387FFFFFFC00000_00 -000000000001DBB1 40FDBB1000000000_00 -FFFFFF8000000000 C260000000000000_00 -FFFFFFFFFFF8007F C11FFE0400000000_00 -FFFFFFFEFD10A515 C1F02EF5AEB00000_00 -FFFFFFC000000000 C250000000000000_00 -FFEFFFFFFFFFFFFE C330000000000002_00 -FAB02984F6283B6C C3953F59EC275F12_01 -FFFFFFE000000000 C240000000000000_00 -FFFFFFBC000001FE C250FFFFFF808000_00 -FEB087C6B9FE7FE0 C374F78394601802_00 -FFFFFFF000000000 C230000000000000_00 -FFF80001000007FE C31FFFFBFFFFE008_00 -00F2762EA6837956 436E4EC5D4D06F2A_01 -FFFFFFF800000000 C220000000000000_00 -FFF7E0FFFFFFFFFE C3203E0000000004_00 -00002E1175484626 42C708BAA4231300_00 -FFFFFFFC00000000 C210000000000000_00 -0000200020000FFE 42C000100007FF00_00 -000000000000068F 409A3C0000000000_00 -FFFFFFFE00000000 C200000000000000_00 -021FFFFFFFFBFFFF 4380FFFFFFFFDFFF_01 -FFFFFFFFFFFFFFF9 C01C000000000000_00 -FFFFFFFF00000000 C1F0000000000000_00 -FFFFFFD0000FFFFD C247FFF800018000_00 -000000BDF6658B83 4267BECCB1706000_00 -FFFFFFFF80000000 C1E0000000000000_00 -1000001FFDFFFFFF 43B000001FFDFFFF_01 -0000000000003B5B 40CDAD8000000000_00 -FFFFFFFFC0000000 C1D0000000000000_00 -FFFFFFBFFE0FFFFF C250007C00004000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -FFFFFFFFE0000000 C1C0000000000000_00 -FFFFFFFBF00007FF C2103FFFE0040000_00 -01E986274F48EAAD 437E986274F48EAA_01 -FFFFFFFFF0000000 C1B0000000000000_00 -1FFFFFFDFFFFFF7F 43BFFFFFFDFFFFFF_01 -FFFFFFFFFFFFCB5A C0CA530000000000_00 -FFFFFFFFF8000000 C1A0000000000000_00 -7FF000000000FFFF 43DFFC000000003F_01 -00000003C2717FC3 420E138BFE180000_00 -FFFFFFFFFC000000 C190000000000000_00 -FFFFFFE00008001F C23FFFF7FFE10000_00 -FFFFFFFFFFEFABDA C130542600000000_00 -FFFFFFFFFE000000 C180000000000000_00 -0200000000000002 4380000000000000_01 -FFFFFFFFF8FDA53F C19C096B04000000_00 -FFFFFFFFFF000000 C170000000000000_00 -F6000003FFFFFFFE C3A3FFFFF8000000_01 -FFFFFFFFFFFFFFD0 C048000000000000_00 -FFFFFFFFFF800000 C160000000000000_00 -FFFFFFFFFFBFFF7E C150002080000000_00 -00000000EE0FEA62 41EDC1FD4C400000_00 -FFFFFFFFFFC00000 C150000000000000_00 -0000007FFF9FFFFD 425FFFE7FFFF4000_00 -00000037F35EDC1D 424BF9AF6E0E8000_00 -FFFFFFFFFFE00000 C140000000000000_00 -FFFFFFF7FDFFFF7D C220040001060000_00 -00000000000001AD 407AD00000000000_00 -FFFFFFFFFFF00000 C130000000000000_00 -FFFFFF0000100020 C26FFFFDFFFC0000_00 -27F167FBC7FC5F9A 43C3F8B3FDE3FE2F_01 -FFFFFFFFFFF80000 C120000000000000_00 -003FFFFFFFFC0001 434FFFFFFFFE0000_01 -000E48F9F4EBD30E 432C91F3E9D7A61C_00 -FFFFFFFFFFFC0000 C110000000000000_00 -DFFFFFFFFFFBFFFE C3C0000000000200_01 -FC91C23EE8C9424F C38B71EE08B9B5ED_01 -FFFFFFFFFFFE0000 C100000000000000_00 -F7DFFBFFFFFFFFFE C3A0400800000000_01 -000000002CAE080C 41C6570406000000_00 -FFFFFFFFFFFF0000 C0F0000000000000_00 -FFFFC00010000020 C2CFFFF7FFFFF000_00 -04D921F917B20E40 43936487E45EC839_00 -FFFFFFFFFFFF8000 C0E0000000000000_00 -F8000FFFFFFFFFFD C39FFFC000000000_01 -FFF17C566BC7D811 C32D075328704FDE_00 -FFFFFFFFFFFFC000 C0D0000000000000_00 -00000000000000FE 406FC00000000000_00 -FFF82AC14930D386 C31F54FADB3CB1E8_00 -FFFFFFFFFFFFE000 C0C0000000000000_00 -00000000000003FC 408FE00000000000_00 -000E62EC60E119FC 432CC5D8C1C233F8_00 -FFFFFFFFFFFFF000 C0B0000000000000_00 -FFFFEFF7FF7FFFFE C2B0080080000200_00 -0E2B1ECF210EEDC5 43AC563D9E421DDB_01 -FFFFFFFFFFFFF800 C0A0000000000000_00 -00000000007FFF1F 415FFFC7C0000000_00 -FFFFFE534F5676F7 C27ACB0A98909000_00 -FFFFFFFFFFFFFC00 C090000000000000_00 -0000001004FFFFFD 423004FFFFFD0000_00 -0000035C939669F1 428AE49CB34F8800_00 -FFFFFFFFFFFFFE00 C080000000000000_00 -1FFFFFFFFFFFFDFD 43BFFFFFFFFFFFFD_01 -FFFFFFFFFFFFFF91 C05BC00000000000_00 -FFFFFFFFFFFFFF00 C070000000000000_00 -01FFFFFFFBFFEFFE 437FFFFFFFBFFEFF_01 -000000000000016E 4076E00000000000_00 -FFFFFFFFFFFFFF80 C060000000000000_00 -FFF7FFFFFFFFF7FD C320000000001006_00 -FFFFF8E2BCFAC553 C29C750C14EAB400_00 -FFFFFFFFFFFFFFC0 C050000000000000_00 -FFFFFBFFFFFE0FFE C290000007C00800_00 -00000001A4E704BF 41FA4E704BF00000_00 -FFFFFFFFFFFFFFE0 C040000000000000_00 -1400007FFFFFFFFD 43B400007FFFFFFF_01 -FFFFFFFC93B187B4 C20B6273C2600000_00 -FFFFFFFFFFFFFFF0 C030000000000000_00 -40000000007FFFFD 43D0000000001FFF_01 -000000000067D468 4159F51A00000000_00 -FFFFFFFFFFFFFFF8 C020000000000000_00 -007FFEFFFFFBFFFE 435FFFBFFFFEFFFF_01 -FFFFFFE26CEC79F8 C23D931386080000_00 -FFFFFFFFFFFFFFFC C010000000000000_00 -00FFFFFF000000FF 436FFFFFE000001F_01 -FFFFFFFFE0D3983A C1BF2C67C6000000_00 -FFFFFFFFFFFFFFFE C000000000000000_00 -00007FFFBFFF7FFE 42DFFFEFFFDFFF80_00 -FFFFFFFDF4A7088A C2005AC7BBB00000_00 -FFFFFFFFFFFFFFFF BFF0000000000000_00 -000008000000027E 42A000000004FC00_00 -000000000000F4E8 40EE9D0000000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFF83FFDF C15F000840000000_00 -00000E11407887B2 42AC2280F10F6400_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -04000003FFFFFFF6 439000000FFFFFFF_01 -0000000000000513 40944C0000000000_00 -FFFFFFFFFFFFFFF7 C022000000000000_00 -BFFC00000000003E C3D000FFFFFFFFFF_01 -00000008D7BBB75B 4221AF776EB60000_00 -FFFFFFFFFFFFFFEF C031000000000000_00 -000FFFFBFFFC0000 432FFFF7FFF80000_00 -FFFFFFFFFFCD5A23 C14952EE80000000_00 -FFFFFFFFFFFFFFDF C040800000000000_00 -FFBFDFFFBFFFFFFF C350080010000000_01 -000000000000007F 405FC00000000000_00 -FFFFFFFFFFFFFFBF C050400000000000_00 -00000007FF800003 421FFE00000C0000_00 -000000000002BB02 4105D81000000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEE7FF C0F1801000000000_00 -00264B2B9BAD0DA2 43432595CDD686D1_00 -FFFFFFFFFFFFFEFF C070100000000000_00 -0000000000100803 4130080300000000_00 -FF9B1DCB9F857D5E C359388D181EA0A8_01 -FFFFFFFFFFFFFDFF C080080000000000_00 -FFFFFFBFFFFFEFEE C250000004048000_00 -F6FD7542899C1C6F C3A205157AECC7C7_01 -FFFFFFFFFFFFFBFF C090040000000000_00 -FF800000004001FF C35FFFFFFFEFFF80_01 -0000000002BE4932 4185F24990000000_00 -FFFFFFFFFFFFF7FF C0A0020000000000_00 -00001004000FFFFE 42B004000FFFFE00_00 -FFFFFF9DAA0123E0 C258957FB7080000_00 -FFFFFFFFFFFFEFFF C0B0010000000000_00 -00000001FDFFFDFE 41FFDFFFDFE00000_00 -FFFC1C8703B1DCB0 C30F1BC7E2711A80_00 -FFFFFFFFFFFFDFFF C0C0008000000000_00 -FE0FE00000000000 C37F020000000000_00 -0779ED944A4E2779 439DE7B65129389D_01 -FFFFFFFFFFFFBFFF C0D0004000000000_00 -FBFFFE0400000000 C3900007F0000000_00 -0000010127E03666 4270127E03666000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -FFFFF0200000FFFE C2AFBFFFFE000400_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFFFFFFEFFFF C0F0001000000000_00 -FFEFFE0000080000 C33001FFFFF80000_00 -FFFFFFFFFD3354EA C1866558B0000000_00 -FFFFFFFFFFFDFFFF C100000800000000_00 -003FF0000003FFFE 434FF8000001FFFF_00 -0000006375B23F7B 4258DD6C8FDEC000_00 -FFFFFFFFFFFBFFFF C110000400000000_00 -000407FFFFFFFFF6 43101FFFFFFFFFD8_00 -0000000092117F38 41E2422FE7000000_00 -FFFFFFFFFFF7FFFF C120000200000000_00 -FFFFFFFFFFFF7FFF C0E0002000000000_00 -00000000000008BE 40A17C0000000000_00 -FFFFFFFFFFEFFFFF C130000100000000_00 -004000020FFFFFFF 4350000083FFFFFF_01 -FFFFB84C2D8BC9CB C2D1ECF49D0D8D40_00 -FFFFFFFFFFDFFFFF C140000080000000_00 -00FFFFFFFFFFFFFD 436FFFFFFFFFFFFF_01 -00000023C2C6F284 4241E16379420000_00 -FFFFFFFFFFBFFFFF C150000040000000_00 -FFFDDFFFFFFFFFFD C301000000000018_00 -00000000746356C4 41DD18D5B1000000_00 -FFFFFFFFFF7FFFFF C160000020000000_00 -010000000000BFFF 4370000000000BFF_01 -FFFFFFFFFFFFFFFD C008000000000000_00 -FFFFFFFFFEFFFFFF C170000010000000_00 -FFFFBF7FFBFFFFFE C2D0200100000080_00 -00000006386CE889 4218E1B3A2240000_00 -FFFFFFFFFDFFFFFF C180000008000000_00 -F00000F7FFFFFFFF C3AFFFFE10000000_01 -FFFDFC53090C46A4 C3001D67B79DCAE0_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -0000000000800047 41600008E0000000_00 -FFFFFFFFD693872E C1C4B63C69000000_00 -FFFFFFFFF7FFFFFF C1A0000002000000_00 -000000007FBFFBFF 41DFEFFEFFC00000_00 -00000026A7845E35 424353C22F1A8000_00 -FFFFFFFFEFFFFFFF C1B0000001000000_00 -FFFFFFDFFFFFFBFD C240000002018000_00 -000000001433D14C 41B433D14C000000_00 -FFFFFFFFDFFFFFFF C1C0000000800000_00 -0001FFFFFFE0000E 42FFFFFFFE0000E0_00 -F0F23E8068D3D84A C3AE1B82FF2E584F_01 -FFFFFFFFBFFFFFFF C1D0000000400000_00 -F7FFBFFFFFFFBFFF C3A0008000000080_01 -FFFFBD29B7459087 C2D0B5922E9BDE40_00 -FFFFFFFF7FFFFFFF C1E0000000200000_00 -FFFFFFF8FFFFBFFF C21C000100040000_00 -FFFFFFFFFFEDDC06 C13223FA00000000_00 -FFFFFFFEFFFFFFFF C1F0000000100000_00 -FFFFFFF80001FFFF C21FFFF800040000_00 -0000000000002FF9 40C7FC8000000000_00 -FFFFFFFDFFFFFFFF C200000000080000_00 -004000040000FFFF 4350000100003FFF_01 -FFFFFFFFFFFFFFF1 C02E000000000000_00 -FFFFFFFBFFFFFFFF C210000000040000_00 -C0000000007FFFFA C3CFFFFFFFFFC000_01 -FFFFFFFFFE053E2B C17FAC1D50000000_00 -FFFFFFF7FFFFFFFF C220000000020000_00 -7FFE000007FFFFFF 43DFFF800001FFFF_01 -000000000000000D 402A000000000000_00 -FFFFFFEFFFFFFFFF C230000000010000_00 -F80000000001007E C39FFFFFFFFFFBFE_01 -FFFFED48424AD9D6 C2B2B7BDB5262A00_00 -FFFFFFDFFFFFFFFF C240000000008000_00 -FFFFFE0001FEFFFF C27FFFE010001000_00 -000000000000013B 4073B00000000000_00 -FFFFFFBFFFFFFFFF C250000000004000_00 -0007FBFFFFFDFFFE 431FEFFFFFF7FFF8_00 -4A16BD4128090C83 43D285AF504A0243_01 -FFFFFF7FFFFFFFFF C260000000002000_00 -00FFF7FFFF7FFFFE 436FFEFFFFEFFFFF_01 -0000000000000006 4018000000000000_00 -FFFFFEFFFFFFFFFF C270000000001000_00 -FBFFFFBFFFBFFFFF C390000100010000_01 -00000000000001BA 407BA00000000000_00 -FFFFFDFFFFFFFFFF C280000000000800_00 -0000000040000082 41D0000020800000_00 -FF07A2BF5B689F89 C36F0BA81492EC0E_01 -FFFFFBFFFFFFFFFF C290000000000400_00 -0000001FF8000008 423FF80000080000_00 -F87CAA7DE672DE8B C39E0D5608663485_01 -FFFFF7FFFFFFFFFF C2A0000000000200_00 -07FFF80000000002 439FFFE000000000_01 -0000000010A1E5B8 41B0A1E5B8000000_00 -FFFFEFFFFFFFFFFF C2B0000000000100_00 -F7FFFFE00007FFFF C3A000003FFFF000_01 -FFFFFFFFFFF6ADFC C122A40800000000_00 -FFFFDFFFFFFFFFFF C2C0000000000080_00 -FFFFFF03FFFFFFC0 C26F800000080000_00 -EA579475948F0032 C3B5A86B8A6B70FF_01 -FFFFBFFFFFFFFFFF C2D0000000000040_00 -FC00000000003FF6 C38FFFFFFFFFFE00_01 -002E677AC313BF60 434733BD6189DFB0_00 -FFFF7FFFFFFFFFFF C2E0000000000020_00 -02000007FF7FFFFF 438000003FFBFFFF_01 -0000000E999639F1 422D332C73E20000_00 -FFFEFFFFFFFFFFFF C2F0000000000010_00 -FFFF83FFFFFFFFBE C2DF000000001080_00 -000000000001537D 40F537D000000000_00 -FFFDFFFFFFFFFFFF C300000000000008_00 -EFFFFFC00000003D C3B000003FFFFFFF_01 -FFFFFFF21FEDFD35 C22BC02405960000_00 -FFFBFFFFFFFFFFFF C310000000000004_00 -FFFFFFF0000007FE C22FFFFFF0040000_00 -FFFFFFFFFFDE0839 C140FBE380000000_00 -FFF7FFFFFFFFFFFF C320000000000002_00 -0000007FFFE000FF 425FFFF8003FC000_00 -FFFFFFFF79F30F48 C1E0C19E17000000_00 -FFEFFFFFFFFFFFFF C330000000000001_00 -FFFFFC13FFFFFFFD C28F600000001800_00 -0000000000001B85 40BB850000000000_00 -FFDFFFFFFFFFFFFF C340000000000000_01 -000008000007FFFE 42A000000FFFFC00_00 -12DB4409E5AE87E6 43B2DB4409E5AE87_01 -FFBFFFFFFFFFFFFF C350000000000000_01 -FFFFFFFFFFF7BFEE C120802400000000_00 -FFFFFFFFFFFFFFFD C008000000000000_00 -FF7FFFFFFFFFFFFF C360000000000000_01 -000000001040FFFE 41B040FFFE000000_00 -00000909A09C13D3 42A213413827A600_00 -FEFFFFFFFFFFFFFF C370000000000000_01 -FFFFFF01FFFFFF7F C26FC00000102000_00 -FFFFFF72E7D2575D C261A305B5146000_00 -FDFFFFFFFFFFFFFF C380000000000000_01 -FFFFFFFFFFFEFFDB C0F0025000000000_00 -0000000000000017 4037000000000000_00 -FBFFFFFFFFFFFFFF C390000000000000_01 -100000001FFFFFF6 43B00000001FFFFF_01 -000000114B12EF51 42314B12EF510000_00 -F7FFFFFFFFFFFFFF C3A0000000000000_01 -0407FFFFFFFFFEFF 43901FFFFFFFFFFB_01 -FFFFFF769F3A5C2C C2612C18B47A8000_00 -EFFFFFFFFFFFFFFF C3B0000000000000_01 -FFFFFFFDF7FFFFFD C200400000180000_00 -FFFFFFFFFFFFFFF2 C02C000000000000_00 -DFFFFFFFFFFFFFFF C3C0000000000000_01 -FFFFFFFFFE0007FF C17FFF8010000000_00 -000000000000001E 403E000000000000_00 -BFFFFFFFFFFFFFFF C3D0000000000000_01 -FFF800000009FFFF C31FFFFFFFD80004_00 -0000000000007AA4 40DEA90000000000_00 -7FFFFFFFFFFFFFFF 43DFFFFFFFFFFFFF_01 -4080000000FFFFFF 43D0200000003FFF_01 -000000000DE7601D 41ABCEC03A000000_00 -3FFFFFFFFFFFFFFF 43CFFFFFFFFFFFFF_01 -FFCFFFFFFFBFFFFE C348000000200001_00 -FFFFFFFFFFFFFFCA C04B000000000000_00 -1FFFFFFFFFFFFFFF 43BFFFFFFFFFFFFF_01 -000080400000003F 42E00800000007E0_00 -00000000001F75A5 413F75A500000000_00 -0FFFFFFFFFFFFFFF 43AFFFFFFFFFFFFF_01 -FFFFFFEFFFFFCFFE C230000030020000_00 -FFFFFEE775887420 C27188A778BE0000_00 -07FFFFFFFFFFFFFF 439FFFFFFFFFFFFF_01 -00000000000801FE 412003FC00000000_00 -0000000000213FF1 41409FF880000000_00 -03FFFFFFFFFFFFFF 438FFFFFFFFFFFFF_01 -07FEFFFFFFFFFFEE 439FFBFFFFFFFFFF_01 -0000000000000004 4010000000000000_00 -01FFFFFFFFFFFFFF 437FFFFFFFFFFFFF_01 -0000000820000003 4220400000060000_00 -FFFFFFF9AD105214 C2194BBEB7B00000_00 -00FFFFFFFFFFFFFF 436FFFFFFFFFFFFF_01 -FFFFF00FFFFFFFBE C2AFE00000008400_00 -FFFFFFFFFFCC48E7 C149DB8C80000000_00 -007FFFFFFFFFFFFF 435FFFFFFFFFFFFF_01 -00000FFFEF7FFFFF 42AFFFDEFFFFFE00_00 -FFFFFFFFFF0BA6CB C16E8B26A0000000_00 -003FFFFFFFFFFFFF 434FFFFFFFFFFFFF_01 -FFFFFF7FBFFFFFBF C260080000082000_00 -FFFFFFFFFFF24425 C12B77B600000000_00 -001FFFFFFFFFFFFF 433FFFFFFFFFFFFF_00 -200000001FFBFFFF 43C00000000FFDFF_01 -FFFFFF4E7115EC53 C26631DD4275A000_00 -000FFFFFFFFFFFFF 432FFFFFFFFFFFFE_00 -FFFFF803FFFFFFBF C29FF00000010400_00 -FFFFFC2E539ADCFE C28E8D6329181000_00 -0007FFFFFFFFFFFF 431FFFFFFFFFFFFC_00 -FFFFFFFFFBFFFFFF C190000004000000_00 -00000055084732F3 42554211CCBCC000_00 -0003FFFFFFFFFFFF 430FFFFFFFFFFFF8_00 -BFFF7FFFFFFFFE00 C3D0002000000000_01 -FFFFFFFFFFFF8543 C0DEAF4000000000_00 -0001FFFFFFFFFFFF 42FFFFFFFFFFFFF0_00 -0000001FFBFFE000 423FFBFFE0000000_00 -FFFFFFFFFFFE491B C0FB6E5000000000_00 -0000FFFFFFFFFFFF 42EFFFFFFFFFFFE0_00 -FC00200000001FFE C38FFEFFFFFFFF00_01 -FFFFF16898822A24 C2AD2ECEFBABB800_00 -00007FFFFFFFFFFF 42DFFFFFFFFFFFC0_00 -3FFF03FFFFFFFFFE 43CFFF81FFFFFFFF_01 -FFFFFF8FFE18C7BF C25C0079CE104000_00 -00003FFFFFFFFFFF 42CFFFFFFFFFFF80_00 -FFFFFEFFFEFFFFFD C270001000003000_00 -00F03620C1266ED9 436E06C41824CDDB_01 -00001FFFFFFFFFFF 42BFFFFFFFFFFF00_00 -BF7EFFFFFFFFFFFF C3D0204000000000_01 -FFFFFFFFFFFFFFD5 C045800000000000_00 -00000FFFFFFFFFFF 42AFFFFFFFFFFE00_00 -FFFBFFFFF803FFFE C31000001FF00008_00 -0000000000068684 411A1A1000000000_00 -000007FFFFFFFFFF 429FFFFFFFFFFC00_00 -DFFFFFE00000001E C3C000000FFFFFFF_01 -FFFFFFFFFFFFECF5 C0B30B0000000000_00 -000003FFFFFFFFFF 428FFFFFFFFFF800_00 -FFFF00400000FFFF C2EFF7FFFFE00020_00 -0000000000000002 4000000000000000_00 -000001FFFFFFFFFF 427FFFFFFFFFF000_00 -FBFFFFFFFFFFBDFE C390000000000108_01 -0000000000000BC9 40A7920000000000_00 -000000FFFFFFFFFF 426FFFFFFFFFE000_00 -807FFFFFFFFFDFFE C3DFE00000000008_01 -FFC274E35A70CD76 C34EC58E52C79945_00 -0000007FFFFFFFFF 425FFFFFFFFFC000_00 -0FFFFFFFFEFFFFFD 43AFFFFFFFFDFFFF_01 -FFFFFFFF00E73AFC C1EFE318A0800000_00 -0000003FFFFFFFFF 424FFFFFFFFF8000_00 -FFC000000001000E C34FFFFFFFFF7FF9_00 -FFFFFFFFFFFE15E9 C0FEA17000000000_00 -0000001FFFFFFFFF 423FFFFFFFFF0000_00 -0001FFFFFFFFF3FD 42FFFFFFFFFF3FD0_00 -0000000000000033 4049800000000000_00 -0000000FFFFFFFFF 422FFFFFFFFE0000_00 -000000001FFFBFFF 41BFFFBFFF000000_00 -FFFFFFEE6B141E1B C23194EBE1E50000_00 -00000007FFFFFFFF 421FFFFFFFFC0000_00 -FFFFFFFFF60007FF C1A3FFF002000000_00 -00000001AB310BA6 41FAB310BA600000_00 -00000003FFFFFFFF 420FFFFFFFF80000_00 -0003FFFFB7FFFFFF 430FFFFDBFFFFFF8_00 -FFFFFFFFFFFFF195 C0ACD60000000000_00 -00000001FFFFFFFF 41FFFFFFFFF00000_00 -FFFFFFFF8000000B C1DFFFFFFD400000_00 -00000019BA8D5559 4239BA8D55590000_00 -00000000FFFFFFFF 41EFFFFFFFE00000_00 -FBFEFFFFFFFFFFF9 C390040000000000_01 -FFFFFFB6F062822D C25243E75F74C000_00 -000000007FFFFFFF 41DFFFFFFFC00000_00 -0001000000000082 42F0000000000820_00 -01CEAD9E2FB104A4 437CEAD9E2FB104A_01 -000000003FFFFFFF 41CFFFFFFF800000_00 -000003FFFFFFFF7C 428FFFFFFFFBE000_00 -FFFFFFFFFD681E78 C184BF0C40000000_00 -000000001FFFFFFF 41BFFFFFFF000000_00 -00002000400001FF 42C000200000FF80_00 -0000000000000018 4038000000000000_00 -000000000FFFFFFF 41AFFFFFFE000000_00 -3FFF80000000003E 43CFFFC000000000_01 -FFFFFFFFFFFFFF95 C05AC00000000000_00 -0000000007FFFFFF 419FFFFFFC000000_00 -010000BFFFFFFFFF 4370000BFFFFFFFF_01 -0000001697087B19 423697087B190000_00 -0000000003FFFFFF 418FFFFFF8000000_00 -FBFFFFFFFFEEFFFD C390000000004400_01 -0000000E64BDFC55 422CC97BF8AA0000_00 -0000000001FFFFFF 417FFFFFF0000000_00 -FC00000001FFFFFE C38FFFFFFFF00000_01 -FFFED156A62AB849 C2F2EA959D547B70_00 -0000000000FFFFFF 416FFFFFE0000000_00 -FFFFFFF83FEFFFFD C21F0040000C0000_00 -00015354EAE7C259 42F5354EAE7C2590_00 -00000000007FFFFF 415FFFFFC0000000_00 -FFFFFFFFFFFFFF7F C060200000000000_00 -FFFFFFF0F4DF3C75 C22E164187160000_00 -00000000003FFFFF 414FFFFF80000000_00 -FFFA000000001FFF C317FFFFFFFF8004_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000001FFFFF 413FFFFF00000000_00 -FFFFFFFFFF7FFE40 C160003800000000_00 -FFFFFFDB5433CB9B C24255E61A328000_00 -00000000000FFFFF 412FFFFE00000000_00 -FFFFFDFFDFFDFFFD C280010010001800_00 -FFFFFFFFFFDEAE1F C140A8F080000000_00 -000000000007FFFF 411FFFFC00000000_00 -FFFFFFFFF0080006 C1AFEFFFF4000000_00 -FFFFFFFE7735DEC7 C1F88CA213900000_00 -000000000003FFFF 410FFFF800000000_00 -00000001FBFFFFFF 41FFBFFFFFF00000_00 -000003757D8B12ED 428BABEC58976800_00 -000000000001FFFF 40FFFFF000000000_00 -FFFFFE07F7FFFFFF C27F808000001000_00 -00000A654064E046 42A4CA80C9C08C00_00 -000000000000FFFF 40EFFFE000000000_00 -08000000000017FF 43A000000000002F_01 -FFFFFFFFFFFFFFE7 C039000000000000_00 -0000000000007FFF 40DFFFC000000000_00 -07FFFFFFFFFFFDF6 439FFFFFFFFFFFF7_01 -FFFFAD78B3D6C3B6 C2D4A1D30A4F1280_00 -0000000000003FFF 40CFFF8000000000_00 -0000300004000000 42C8000200000000_00 -FFFFFFF70B77F34F C221E91019620000_00 -0000000000001FFF 40BFFF0000000000_00 -FFFFFF80006FFFFE C25FFFE400008000_00 -0000013EB4D67EC8 4273EB4D67EC8000_00 -0000000000000FFF 40AFFE0000000000_00 -BFFFDFFFFBFFFFFF C3D0000800010000_01 -0005CEAF34EA1DC7 43173ABCD3A8771C_00 -00000000000007FF 409FFC0000000000_00 -00004800007FFFFD 42D200001FFFFF40_00 -FFFFFFFFFFFFFFFB C014000000000000_00 -00000000000003FF 408FF80000000000_00 -0000000200001000 4200000080000000_00 -00000000000360D0 410B068000000000_00 -00000000000001FF 407FF00000000000_00 -01003FFFFFFFFFFC 437003FFFFFFFFFF_01 -00C000708FF1BA51 4368000E11FE374A_01 -00000000000000FF 406FE00000000000_00 -F802000003FFFFFF C39FF7FFFFF00000_01 -0F9E07DCC0BDC061 43AF3C0FB9817B80_01 -000000000000007F 405FC00000000000_00 -03FF0000000000FF 438FF80000000007_01 -FFFFFFE1B9B2A079 C23E464D5F870000_00 -000000000000003F 404F800000000000_00 -FFF80000000080FF C31FFFFFFFFDFC04_00 -00000000001EB5B4 413EB5B400000000_00 -000000000000001F 403F000000000000_00 -000000000077FBFE 415DFEFF80000000_00 -00000000005AC607 4156B181C0000000_00 -000000000000000F 402E000000000000_00 -FFFFFFFEF80000FF C1F07FFFF0100000_00 -000005C5B9D66984 429716E759A61000_00 -0000000000000007 401C000000000000_00 -C001FFFFFFF00000 C3CFFF0000000800_00 -00001D06B372AA06 42BD06B372AA0600_00 -0000000000000003 4008000000000000_00 +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFD_01 +0000000032CC8B7A_41C96645BD000000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_C1CFFFE001000000_00 +032C857F319EDE38_4389642BF98CF6F1_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_C29000001FFF0800_00 +00394C79B6D3007B_434CA63CDB69803D_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_C39000003FFFFFF8_01 +0000000001AE458D_417AE458D0000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +F9EB456140D88764_C39852EA7AFC9DE2_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_C2BBFF0000000200_00 +07DE834A248EDF36_439F7A0D28923B7C_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +FFFFFFFFFFE385E2_C13C7A1E00000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_C3AFF7C000000000_01 +000000059EB1FD45_42167AC7F5140000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_C108003800000000_00 +FFFFFFFFFFFEDDFE_C0F2202000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000000C89FF56B_41E913FEAD600000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +1B5E4F0BE0DEBFF0_43BB5E4F0BE0DEBF_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_C3003FE000000008_00 +FFFFFFFFFFF4766B_C127132A00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000000C_4028000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +FFE662A109109D0A_C3399D5EF6EF62F6_00 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_C3CFFFFFFFE40000_01 +FFFFFFFFFFFFFFE4_C03C000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_C39FFBFFFFFFC000_00 +FE114B79075F70EE_C37EEB486F8A08F1_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000100_01 +00000000000003AC_408D600000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +00000044A3A3DBE5_425128E8F6F94000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_C33FFFC100000001_00 +FFFFFFFFFFFF1A91_C0ECADE000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_C2A0780000000600_00 +0000000000003309_40C9848000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +FFFFFFFFFFFFFF58_C065000000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_C240FF0000010000_00 +0000000000002980_40C4C00000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +000000000000005D_4057400000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +FFFC8C23DA2CEAD8_C30B9EE12E98A940_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_C3BFFFFFFFFFC000_01 +FFFFFDE3C1DEC43C_C280E1F109DE2000_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_C2EFFFFE80000060_00 +000000000030FFBE_41487FDF00000000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_C2FFFFFF80010030_00 +FFFFFFFFEFDEED86_C1B021127A000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_C3A8000000008000_01 +000000001DA3FF45_41BDA3FF45000000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_C1EFFFDFFF200000_00 +FFFFFFFE9B1BCB54_C1F64E434AC00000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +F27DD19DE6563714_C3AB045CC4335391_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_C34FFFFFFFDFFC01_00 +000000000001A359_40FA359000000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +FFFFFFFFFE62EC20_C179D13E00000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000285F_40C42F8000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_C1D00003FC400000_00 +FFFFF836F99DBAA8_C29F241989156000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0033466832042D47_4349A334190216A3_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_C09DE40000000000_00 +00000000003829C8_414C14E400000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000000FB77C672B_422F6EF8CE560000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFBFFFFFF_01 +0000000000001B78_40BB780000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_C360000000020400_01 +0000000000000071_405C400000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +FFFFFFFFFFFFFF86_C05E800000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +FFF8A60D9E19F17E_C31D67C987983A08_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +FFFFFFFFF7506DBA_C1A15F248C000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_C0F0409000000000_00 +FFFFFFFFFEA42AC9_C175BD5370000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +FFE7AA3F2BDACC89_C33855C0D4253377_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_C31FEFFFFFF00000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_C2DFFFFDFFFFF840_00 +FFFDF681DECDADC9_C3004BF1099291B8_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_C2700001FFF81000_00 +FFFFFFFFFFFFCFBE_C0C8210000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +FEC01FECA24DE1B0_C373FE0135DB21E5_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_C3A0000000400100_01 +F858A66761669936_C39E9D66627A659B_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_C2F007FFFFFFFC20_00 +F716EA43FAC45C97_C3A1D22B780A7746_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_C04D000000000000_00 +0024D70EC7661FD8_43426B8763B30FEC_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_C3CFC00000000000_01 +FFD956DBD0AEE817_C343549217A88BF4_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F7FFFFFFF_01 +FFFFFFFFFFFF4300_C0E7A00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +C12EDF40F41F6021_C3CF68905F85F04F_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_C35BFFFFFFFFFFF8_01 +FFFFFFF83DE950F6_C21F085ABC280000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_C3DFFFFF00000100_00 +FE2B59CB3A604D69_C37D4A634C59FB29_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFEF_01 +000000A37C210862_42646F84210C4000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +FFFFB65CD8617789_C2D268C9E7A21DC0_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +FFFFFFFFFFFFF01D_C0AFC60000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B000008000003F_01 +000000000D098D19_41AA131A32000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFAF_01 +000006B3BD2C7BEF_429ACEF4B1EFBC00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +FFFF4E5ADDDAA4A8_C2E634A444AB6B00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +FFFFFFFFFFFFFF21_C06BE00000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +FFFFFFFFFC648262_C18CDBECF0000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_C3CFFFF000000000_01 +FFFFFF7353AC45D2_C261958A7745C000_00 +8000000000000000_C3E0000000000000_00 +FFFFFFFFFFE7EFFF_C138100100000000_00 +0000000000A1202D_41642405A0000000_00 +C000000000000000_C3D0000000000000_00 +FFFFFFFFFFFF5F7F_C0E4102000000000_00 +000000000040CA70_4150329C00000000_00 +E000000000000000_C3C0000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000003B55D87D4_420DAAEC3EA00000_00 +F000000000000000_C3B0000000000000_00 +FF80000DFFFFFFFF_C35FFFFC80000000_01 +000000010510FAEF_41F0510FAEF00000_00 +F800000000000000_C3A0000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000000724A_40DC928000000000_00 +FC00000000000000_C390000000000000_00 +FFFFFFDF80000002_C2403FFFFFFF0000_00 +0000000000000064_4059000000000000_00 +FE00000000000000_C380000000000000_00 +FEFFFFFFFFF800FE_C370000000007FF0_01 +FFFFFFC2C6222702_C24E9CEEEC7F0000_00 +FF00000000000000_C370000000000000_00 +0000000408000002_4210200000080000_00 +000000E96DF1CB41_426D2DBE39682000_00 +FF80000000000000_C360000000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE7F_01 +F727F174DEE7DC85_C3A1B01D16423046_01 +FFC0000000000000_C350000000000000_00 +8000000003FFFEFE_C3DFFFFFFFFF0000_01 +FFFFFFFFFFF0BD5B_C12E854A00000000_00 +FFE0000000000000_C340000000000000_00 +0BEFFFFFFFFFFFFF_43A7DFFFFFFFFFFF_01 +000000000002790C_4103C86000000000_00 +FFF0000000000000_C330000000000000_00 +FFFFFFFFFFEFFBFA_C130040600000000_00 +000000169E75DF01_42369E75DF010000_00 +FFF8000000000000_C320000000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000000E_402C000000000000_00 +FFFC000000000000_C310000000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +FFFFFFFFFFF28622_C12AF3BC00000000_00 +FFFE000000000000_C300000000000000_00 +FFFFFF7FFFFDF7FF_C260000041002000_00 +00072F0EC496FE21_431CBC3B125BF884_00 +FFFF000000000000_C2F0000000000000_00 +DFBFFFFFFFFFFFFE_C3C0200000000000_01 +0000000000FC1FCA_416F83F940000000_00 +FFFF800000000000_C2E0000000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +FFFF5194E4A9C2CE_C2E5CD636AC7A640_00 +FFFFC00000000000_C2D0000000000000_00 +00000002100007FD_420080003FE80000_00 +FFFFFFFFFFC2D8FE_C14E938100000000_00 +FFFFE00000000000_C2C0000000000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000001766E_40F766E000000000_00 +FFFFF00000000000_C2B0000000000000_00 +0040000400000002_4350000100000000_01 +0000000000007841_40DE104000000000_00 +FFFFF80000000000_C2A0000000000000_00 +3DFFFFFFFFFFFF7E_43CEFFFFFFFFFFFF_01 +FFFFFFE549E17E30_C23AB61E81D00000_00 +FFFFFC0000000000_C290000000000000_00 +FFFFFFFFFFFFFEE1_C071F00000000000_00 +FFFFFFFFFFFFFFE7_C039000000000000_00 +FFFFFE0000000000_C280000000000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +FFFFFFFFFFFFFF73_C061A00000000000_00 +FFFFFF0000000000_C270000000000000_00 +FD00000008000000_C387FFFFFFC00000_00 +000000000001DBB1_40FDBB1000000000_00 +FFFFFF8000000000_C260000000000000_00 +FFFFFFFFFFF8007F_C11FFE0400000000_00 +FFFFFFFEFD10A515_C1F02EF5AEB00000_00 +FFFFFFC000000000_C250000000000000_00 +FFEFFFFFFFFFFFFE_C330000000000002_00 +FAB02984F6283B6C_C3953F59EC275F12_01 +FFFFFFE000000000_C240000000000000_00 +FFFFFFBC000001FE_C250FFFFFF808000_00 +FEB087C6B9FE7FE0_C374F78394601802_00 +FFFFFFF000000000_C230000000000000_00 +FFF80001000007FE_C31FFFFBFFFFE008_00 +00F2762EA6837956_436E4EC5D4D06F2A_01 +FFFFFFF800000000_C220000000000000_00 +FFF7E0FFFFFFFFFE_C3203E0000000004_00 +00002E1175484626_42C708BAA4231300_00 +FFFFFFFC00000000_C210000000000000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000068F_409A3C0000000000_00 +FFFFFFFE00000000_C200000000000000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFDFFF_01 +FFFFFFFFFFFFFFF9_C01C000000000000_00 +FFFFFFFF00000000_C1F0000000000000_00 +FFFFFFD0000FFFFD_C247FFF800018000_00 +000000BDF6658B83_4267BECCB1706000_00 +FFFFFFFF80000000_C1E0000000000000_00 +1000001FFDFFFFFF_43B000001FFDFFFF_01 +0000000000003B5B_40CDAD8000000000_00 +FFFFFFFFC0000000_C1D0000000000000_00 +FFFFFFBFFE0FFFFF_C250007C00004000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +FFFFFFFFE0000000_C1C0000000000000_00 +FFFFFFFBF00007FF_C2103FFFE0040000_00 +01E986274F48EAAD_437E986274F48EAA_01 +FFFFFFFFF0000000_C1B0000000000000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFDFFFFFF_01 +FFFFFFFFFFFFCB5A_C0CA530000000000_00 +FFFFFFFFF8000000_C1A0000000000000_00 +7FF000000000FFFF_43DFFC000000003F_01 +00000003C2717FC3_420E138BFE180000_00 +FFFFFFFFFC000000_C190000000000000_00 +FFFFFFE00008001F_C23FFFF7FFE10000_00 +FFFFFFFFFFEFABDA_C130542600000000_00 +FFFFFFFFFE000000_C180000000000000_00 +0200000000000002_4380000000000000_01 +FFFFFFFFF8FDA53F_C19C096B04000000_00 +FFFFFFFFFF000000_C170000000000000_00 +F6000003FFFFFFFE_C3A3FFFFF8000000_01 +FFFFFFFFFFFFFFD0_C048000000000000_00 +FFFFFFFFFF800000_C160000000000000_00 +FFFFFFFFFFBFFF7E_C150002080000000_00 +00000000EE0FEA62_41EDC1FD4C400000_00 +FFFFFFFFFFC00000_C150000000000000_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000037F35EDC1D_424BF9AF6E0E8000_00 +FFFFFFFFFFE00000_C140000000000000_00 +FFFFFFF7FDFFFF7D_C220040001060000_00 +00000000000001AD_407AD00000000000_00 +FFFFFFFFFFF00000_C130000000000000_00 +FFFFFF0000100020_C26FFFFDFFFC0000_00 +27F167FBC7FC5F9A_43C3F8B3FDE3FE2F_01 +FFFFFFFFFFF80000_C120000000000000_00 +003FFFFFFFFC0001_434FFFFFFFFE0000_01 +000E48F9F4EBD30E_432C91F3E9D7A61C_00 +FFFFFFFFFFFC0000_C110000000000000_00 +DFFFFFFFFFFBFFFE_C3C0000000000200_01 +FC91C23EE8C9424F_C38B71EE08B9B5ED_01 +FFFFFFFFFFFE0000_C100000000000000_00 +F7DFFBFFFFFFFFFE_C3A0400800000000_01 +000000002CAE080C_41C6570406000000_00 +FFFFFFFFFFFF0000_C0F0000000000000_00 +FFFFC00010000020_C2CFFFF7FFFFF000_00 +04D921F917B20E40_43936487E45EC839_00 +FFFFFFFFFFFF8000_C0E0000000000000_00 +F8000FFFFFFFFFFD_C39FFFC000000000_01 +FFF17C566BC7D811_C32D075328704FDE_00 +FFFFFFFFFFFFC000_C0D0000000000000_00 +00000000000000FE_406FC00000000000_00 +FFF82AC14930D386_C31F54FADB3CB1E8_00 +FFFFFFFFFFFFE000_C0C0000000000000_00 +00000000000003FC_408FE00000000000_00 +000E62EC60E119FC_432CC5D8C1C233F8_00 +FFFFFFFFFFFFF000_C0B0000000000000_00 +FFFFEFF7FF7FFFFE_C2B0080080000200_00 +0E2B1ECF210EEDC5_43AC563D9E421DDB_01 +FFFFFFFFFFFFF800_C0A0000000000000_00 +00000000007FFF1F_415FFFC7C0000000_00 +FFFFFE534F5676F7_C27ACB0A98909000_00 +FFFFFFFFFFFFFC00_C090000000000000_00 +0000001004FFFFFD_423004FFFFFD0000_00 +0000035C939669F1_428AE49CB34F8800_00 +FFFFFFFFFFFFFE00_C080000000000000_00 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFD_01 +FFFFFFFFFFFFFF91_C05BC00000000000_00 +FFFFFFFFFFFFFF00_C070000000000000_00 +01FFFFFFFBFFEFFE_437FFFFFFFBFFEFF_01 +000000000000016E_4076E00000000000_00 +FFFFFFFFFFFFFF80_C060000000000000_00 +FFF7FFFFFFFFF7FD_C320000000001006_00 +FFFFF8E2BCFAC553_C29C750C14EAB400_00 +FFFFFFFFFFFFFFC0_C050000000000000_00 +FFFFFBFFFFFE0FFE_C290000007C00800_00 +00000001A4E704BF_41FA4E704BF00000_00 +FFFFFFFFFFFFFFE0_C040000000000000_00 +1400007FFFFFFFFD_43B400007FFFFFFF_01 +FFFFFFFC93B187B4_C20B6273C2600000_00 +FFFFFFFFFFFFFFF0_C030000000000000_00 +40000000007FFFFD_43D0000000001FFF_01 +000000000067D468_4159F51A00000000_00 +FFFFFFFFFFFFFFF8_C020000000000000_00 +007FFEFFFFFBFFFE_435FFFBFFFFEFFFF_01 +FFFFFFE26CEC79F8_C23D931386080000_00 +FFFFFFFFFFFFFFFC_C010000000000000_00 +00FFFFFF000000FF_436FFFFFE000001F_01 +FFFFFFFFE0D3983A_C1BF2C67C6000000_00 +FFFFFFFFFFFFFFFE_C000000000000000_00 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +FFFFFFFDF4A7088A_C2005AC7BBB00000_00 +FFFFFFFFFFFFFFFF_BFF0000000000000_00 +000008000000027E_42A000000004FC00_00 +000000000000F4E8_40EE9D0000000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFF83FFDF_C15F000840000000_00 +00000E11407887B2_42AC2280F10F6400_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +04000003FFFFFFF6_439000000FFFFFFF_01 +0000000000000513_40944C0000000000_00 +FFFFFFFFFFFFFFF7_C022000000000000_00 +BFFC00000000003E_C3D000FFFFFFFFFF_01 +00000008D7BBB75B_4221AF776EB60000_00 +FFFFFFFFFFFFFFEF_C031000000000000_00 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +FFFFFFFFFFCD5A23_C14952EE80000000_00 +FFFFFFFFFFFFFFDF_C040800000000000_00 +FFBFDFFFBFFFFFFF_C350080010000000_01 +000000000000007F_405FC00000000000_00 +FFFFFFFFFFFFFFBF_C050400000000000_00 +00000007FF800003_421FFE00000C0000_00 +000000000002BB02_4105D81000000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEE7FF_C0F1801000000000_00 +00264B2B9BAD0DA2_43432595CDD686D1_00 +FFFFFFFFFFFFFEFF_C070100000000000_00 +0000000000100803_4130080300000000_00 +FF9B1DCB9F857D5E_C359388D181EA0A8_01 +FFFFFFFFFFFFFDFF_C080080000000000_00 +FFFFFFBFFFFFEFEE_C250000004048000_00 +F6FD7542899C1C6F_C3A205157AECC7C7_01 +FFFFFFFFFFFFFBFF_C090040000000000_00 +FF800000004001FF_C35FFFFFFFEFFF80_01 +0000000002BE4932_4185F24990000000_00 +FFFFFFFFFFFFF7FF_C0A0020000000000_00 +00001004000FFFFE_42B004000FFFFE00_00 +FFFFFF9DAA0123E0_C258957FB7080000_00 +FFFFFFFFFFFFEFFF_C0B0010000000000_00 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +FFFC1C8703B1DCB0_C30F1BC7E2711A80_00 +FFFFFFFFFFFFDFFF_C0C0008000000000_00 +FE0FE00000000000_C37F020000000000_00 +0779ED944A4E2779_439DE7B65129389D_01 +FFFFFFFFFFFFBFFF_C0D0004000000000_00 +FBFFFE0400000000_C3900007F0000000_00 +0000010127E03666_4270127E03666000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +FFFFF0200000FFFE_C2AFBFFFFE000400_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFFFFFFEFFFF_C0F0001000000000_00 +FFEFFE0000080000_C33001FFFFF80000_00 +FFFFFFFFFD3354EA_C1866558B0000000_00 +FFFFFFFFFFFDFFFF_C100000800000000_00 +003FF0000003FFFE_434FF8000001FFFF_00 +0000006375B23F7B_4258DD6C8FDEC000_00 +FFFFFFFFFFFBFFFF_C110000400000000_00 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000092117F38_41E2422FE7000000_00 +FFFFFFFFFFF7FFFF_C120000200000000_00 +FFFFFFFFFFFF7FFF_C0E0002000000000_00 +00000000000008BE_40A17C0000000000_00 +FFFFFFFFFFEFFFFF_C130000100000000_00 +004000020FFFFFFF_4350000083FFFFFF_01 +FFFFB84C2D8BC9CB_C2D1ECF49D0D8D40_00 +FFFFFFFFFFDFFFFF_C140000080000000_00 +00FFFFFFFFFFFFFD_436FFFFFFFFFFFFF_01 +00000023C2C6F284_4241E16379420000_00 +FFFFFFFFFFBFFFFF_C150000040000000_00 +FFFDDFFFFFFFFFFD_C301000000000018_00 +00000000746356C4_41DD18D5B1000000_00 +FFFFFFFFFF7FFFFF_C160000020000000_00 +010000000000BFFF_4370000000000BFF_01 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FFFFFFFFFEFFFFFF_C170000010000000_00 +FFFFBF7FFBFFFFFE_C2D0200100000080_00 +00000006386CE889_4218E1B3A2240000_00 +FFFFFFFFFDFFFFFF_C180000008000000_00 +F00000F7FFFFFFFF_C3AFFFFE10000000_01 +FFFDFC53090C46A4_C3001D67B79DCAE0_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +0000000000800047_41600008E0000000_00 +FFFFFFFFD693872E_C1C4B63C69000000_00 +FFFFFFFFF7FFFFFF_C1A0000002000000_00 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000026A7845E35_424353C22F1A8000_00 +FFFFFFFFEFFFFFFF_C1B0000001000000_00 +FFFFFFDFFFFFFBFD_C240000002018000_00 +000000001433D14C_41B433D14C000000_00 +FFFFFFFFDFFFFFFF_C1C0000000800000_00 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +F0F23E8068D3D84A_C3AE1B82FF2E584F_01 +FFFFFFFFBFFFFFFF_C1D0000000400000_00 +F7FFBFFFFFFFBFFF_C3A0008000000080_01 +FFFFBD29B7459087_C2D0B5922E9BDE40_00 +FFFFFFFF7FFFFFFF_C1E0000000200000_00 +FFFFFFF8FFFFBFFF_C21C000100040000_00 +FFFFFFFFFFEDDC06_C13223FA00000000_00 +FFFFFFFEFFFFFFFF_C1F0000000100000_00 +FFFFFFF80001FFFF_C21FFFF800040000_00 +0000000000002FF9_40C7FC8000000000_00 +FFFFFFFDFFFFFFFF_C200000000080000_00 +004000040000FFFF_4350000100003FFF_01 +FFFFFFFFFFFFFFF1_C02E000000000000_00 +FFFFFFFBFFFFFFFF_C210000000040000_00 +C0000000007FFFFA_C3CFFFFFFFFFC000_01 +FFFFFFFFFE053E2B_C17FAC1D50000000_00 +FFFFFFF7FFFFFFFF_C220000000020000_00 +7FFE000007FFFFFF_43DFFF800001FFFF_01 +000000000000000D_402A000000000000_00 +FFFFFFEFFFFFFFFF_C230000000010000_00 +F80000000001007E_C39FFFFFFFFFFBFE_01 +FFFFED48424AD9D6_C2B2B7BDB5262A00_00 +FFFFFFDFFFFFFFFF_C240000000008000_00 +FFFFFE0001FEFFFF_C27FFFE010001000_00 +000000000000013B_4073B00000000000_00 +FFFFFFBFFFFFFFFF_C250000000004000_00 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0243_01 +FFFFFF7FFFFFFFFF_C260000000002000_00 +00FFF7FFFF7FFFFE_436FFEFFFFEFFFFF_01 +0000000000000006_4018000000000000_00 +FFFFFEFFFFFFFFFF_C270000000001000_00 +FBFFFFBFFFBFFFFF_C390000100010000_01 +00000000000001BA_407BA00000000000_00 +FFFFFDFFFFFFFFFF_C280000000000800_00 +0000000040000082_41D0000020800000_00 +FF07A2BF5B689F89_C36F0BA81492EC0E_01 +FFFFFBFFFFFFFFFF_C290000000000400_00 +0000001FF8000008_423FF80000080000_00 +F87CAA7DE672DE8B_C39E0D5608663485_01 +FFFFF7FFFFFFFFFF_C2A0000000000200_00 +07FFF80000000002_439FFFE000000000_01 +0000000010A1E5B8_41B0A1E5B8000000_00 +FFFFEFFFFFFFFFFF_C2B0000000000100_00 +F7FFFFE00007FFFF_C3A000003FFFF000_01 +FFFFFFFFFFF6ADFC_C122A40800000000_00 +FFFFDFFFFFFFFFFF_C2C0000000000080_00 +FFFFFF03FFFFFFC0_C26F800000080000_00 +EA579475948F0032_C3B5A86B8A6B70FF_01 +FFFFBFFFFFFFFFFF_C2D0000000000040_00 +FC00000000003FF6_C38FFFFFFFFFFE00_01 +002E677AC313BF60_434733BD6189DFB0_00 +FFFF7FFFFFFFFFFF_C2E0000000000020_00 +02000007FF7FFFFF_438000003FFBFFFF_01 +0000000E999639F1_422D332C73E20000_00 +FFFEFFFFFFFFFFFF_C2F0000000000010_00 +FFFF83FFFFFFFFBE_C2DF000000001080_00 +000000000001537D_40F537D000000000_00 +FFFDFFFFFFFFFFFF_C300000000000008_00 +EFFFFFC00000003D_C3B000003FFFFFFF_01 +FFFFFFF21FEDFD35_C22BC02405960000_00 +FFFBFFFFFFFFFFFF_C310000000000004_00 +FFFFFFF0000007FE_C22FFFFFF0040000_00 +FFFFFFFFFFDE0839_C140FBE380000000_00 +FFF7FFFFFFFFFFFF_C320000000000002_00 +0000007FFFE000FF_425FFFF8003FC000_00 +FFFFFFFF79F30F48_C1E0C19E17000000_00 +FFEFFFFFFFFFFFFF_C330000000000001_00 +FFFFFC13FFFFFFFD_C28F600000001800_00 +0000000000001B85_40BB850000000000_00 +FFDFFFFFFFFFFFFF_C340000000000000_01 +000008000007FFFE_42A000000FFFFC00_00 +12DB4409E5AE87E6_43B2DB4409E5AE87_01 +FFBFFFFFFFFFFFFF_C350000000000000_01 +FFFFFFFFFFF7BFEE_C120802400000000_00 +FFFFFFFFFFFFFFFD_C008000000000000_00 +FF7FFFFFFFFFFFFF_C360000000000000_01 +000000001040FFFE_41B040FFFE000000_00 +00000909A09C13D3_42A213413827A600_00 +FEFFFFFFFFFFFFFF_C370000000000000_01 +FFFFFF01FFFFFF7F_C26FC00000102000_00 +FFFFFF72E7D2575D_C261A305B5146000_00 +FDFFFFFFFFFFFFFF_C380000000000000_01 +FFFFFFFFFFFEFFDB_C0F0025000000000_00 +0000000000000017_4037000000000000_00 +FBFFFFFFFFFFFFFF_C390000000000000_01 +100000001FFFFFF6_43B00000001FFFFF_01 +000000114B12EF51_42314B12EF510000_00 +F7FFFFFFFFFFFFFF_C3A0000000000000_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFB_01 +FFFFFF769F3A5C2C_C2612C18B47A8000_00 +EFFFFFFFFFFFFFFF_C3B0000000000000_01 +FFFFFFFDF7FFFFFD_C200400000180000_00 +FFFFFFFFFFFFFFF2_C02C000000000000_00 +DFFFFFFFFFFFFFFF_C3C0000000000000_01 +FFFFFFFFFE0007FF_C17FFF8010000000_00 +000000000000001E_403E000000000000_00 +BFFFFFFFFFFFFFFF_C3D0000000000000_01 +FFF800000009FFFF_C31FFFFFFFD80004_00 +0000000000007AA4_40DEA90000000000_00 +7FFFFFFFFFFFFFFF_43DFFFFFFFFFFFFF_01 +4080000000FFFFFF_43D0200000003FFF_01 +000000000DE7601D_41ABCEC03A000000_00 +3FFFFFFFFFFFFFFF_43CFFFFFFFFFFFFF_01 +FFCFFFFFFFBFFFFE_C348000000200001_00 +FFFFFFFFFFFFFFCA_C04B000000000000_00 +1FFFFFFFFFFFFFFF_43BFFFFFFFFFFFFF_01 +000080400000003F_42E00800000007E0_00 +00000000001F75A5_413F75A500000000_00 +0FFFFFFFFFFFFFFF_43AFFFFFFFFFFFFF_01 +FFFFFFEFFFFFCFFE_C230000030020000_00 +FFFFFEE775887420_C27188A778BE0000_00 +07FFFFFFFFFFFFFF_439FFFFFFFFFFFFF_01 +00000000000801FE_412003FC00000000_00 +0000000000213FF1_41409FF880000000_00 +03FFFFFFFFFFFFFF_438FFFFFFFFFFFFF_01 +07FEFFFFFFFFFFEE_439FFBFFFFFFFFFF_01 +0000000000000004_4010000000000000_00 +01FFFFFFFFFFFFFF_437FFFFFFFFFFFFF_01 +0000000820000003_4220400000060000_00 +FFFFFFF9AD105214_C2194BBEB7B00000_00 +00FFFFFFFFFFFFFF_436FFFFFFFFFFFFF_01 +FFFFF00FFFFFFFBE_C2AFE00000008400_00 +FFFFFFFFFFCC48E7_C149DB8C80000000_00 +007FFFFFFFFFFFFF_435FFFFFFFFFFFFF_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +FFFFFFFFFF0BA6CB_C16E8B26A0000000_00 +003FFFFFFFFFFFFF_434FFFFFFFFFFFFF_01 +FFFFFF7FBFFFFFBF_C260080000082000_00 +FFFFFFFFFFF24425_C12B77B600000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFDFF_01 +FFFFFF4E7115EC53_C26631DD4275A000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_C29FF00000010400_00 +FFFFFC2E539ADCFE_C28E8D6329181000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_C190000004000000_00 +00000055084732F3_42554211CCBCC000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_C3D0002000000000_01 +FFFFFFFFFFFF8543_C0DEAF4000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +FFFFFFFFFFFE491B_C0FB6E5000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_C38FFEFFFFFFFF00_01 +FFFFF16898822A24_C2AD2ECEFBABB800_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF81FFFFFFFF_01 +FFFFFF8FFE18C7BF_C25C0079CE104000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_C270001000003000_00 +00F03620C1266ED9_436E06C41824CDDB_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_C3D0204000000000_01 +FFFFFFFFFFFFFFD5_C045800000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_C31000001FF00008_00 +0000000000068684_411A1A1000000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_C3C000000FFFFFFF_01 +FFFFFFFFFFFFECF5_C0B30B0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_C2EFF7FFFFE00020_00 +0000000000000002_4000000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_C390000000000108_01 +0000000000000BC9_40A7920000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_C3DFE00000000008_01 +FFC274E35A70CD76_C34EC58E52C79945_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFDFFFF_01 +FFFFFFFF00E73AFC_C1EFE318A0800000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_C34FFFFFFFFF7FF9_00 +FFFFFFFFFFFE15E9_C0FEA17000000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +0000000000000033_4049800000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +FFFFFFEE6B141E1B_C23194EBE1E50000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_C1A3FFF002000000_00 +00000001AB310BA6_41FAB310BA600000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +FFFFFFFFFFFFF195_C0ACD60000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_C1DFFFFFFD400000_00 +00000019BA8D5559_4239BA8D55590000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_C390040000000000_01 +FFFFFFB6F062822D_C25243E75F74C000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +01CEAD9E2FB104A4_437CEAD9E2FB104A_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +FFFFFFFFFD681E78_C184BF0C40000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000018_4038000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000000_01 +FFFFFFFFFFFFFF95_C05AC00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000BFFFFFFFF_01 +0000001697087B19_423697087B190000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_C390000000004400_01 +0000000E64BDFC55_422CC97BF8AA0000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_C38FFFFFFFF00000_01 +FFFED156A62AB849_C2F2EA959D547B70_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_C21F0040000C0000_00 +00015354EAE7C259_42F5354EAE7C2590_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_C060200000000000_00 +FFFFFFF0F4DF3C75_C22E164187160000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_C317FFFFFFFF8004_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_C160003800000000_00 +FFFFFFDB5433CB9B_C24255E61A328000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_C280010010001800_00 +FFFFFFFFFFDEAE1F_C140A8F080000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_C1AFEFFFF4000000_00 +FFFFFFFE7735DEC7_C1F88CA213900000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000003757D8B12ED_428BABEC58976800_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_C27F808000001000_00 +00000A654064E046_42A4CA80C9C08C00_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A000000000002F_01 +FFFFFFFFFFFFFFE7_C039000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF7_01 +FFFFAD78B3D6C3B6_C2D4A1D30A4F1280_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +FFFFFFF70B77F34F_C221E91019620000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_C25FFFE400008000_00 +0000013EB4D67EC8_4273EB4D67EC8000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_C3D0000800010000_01 +0005CEAF34EA1DC7_43173ABCD3A8771C_00 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +FFFFFFFFFFFFFFFB_C014000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000360D0_410B068000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_437003FFFFFFFFFF_01 +00C000708FF1BA51_4368000E11FE374A_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_C39FF7FFFFF00000_01 +0F9E07DCC0BDC061_43AF3C0FB9817B80_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000007_01 +FFFFFFE1B9B2A079_C23E464D5F870000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_C31FFFFFFFFDFC04_00 +00000000001EB5B4_413EB5B400000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +00000000005AC607_4156B181C0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_C1F07FFFF0100000_00 +000005C5B9D66984_429716E759A61000_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_C3CFFF0000000800_00 +00001D06B372AA06_42BD06B372AA0600_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f32_rd.tv b/wally-pipelined/testbench/fp/ui32_f32_rd.tv new file mode 100644 index 000000000..aa109500c --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f32_rd.tv @@ -0,0 +1,372 @@ +1FEFFFEF_4DFF7FFF_01 +0000448E_46891C00_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00019E14_47CF0A00_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +0000DE38_475E3800_00 +00000002_40000000_00 +FFDFFC02_4F7FDFFC_01 +03794C79_4C5E531E_01 +00000004_40800000_00 +F00FFFFE_4F700FFF_01 +00010A95_47854A80_00 +00000008_41000000_00 +FFFFF97F_4F7FFFF9_01 +01AE458D_4BD722C6_01 +00000010_41800000_00 +0101001E_4B80800F_00 +69EB4561_4ED3D68A_01 +00000020_42000000_00 +8001FFEE_4F0001FF_01 +0003DD08_48774200_00 +00000040_42800000_00 +FFF03FF9_4F7FF03F_01 +000EDF36_496DF360_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000679_44CF2000_00 +00000100_43800000_00 +BFFFFFEF_4F3FFFFF_01 +0000000F_41700000_00 +00000200_44000000_00 +010BFFFD_4B85FFFE_01 +00000590_44B20000_00 +00000400_44800000_00 +F7FFFEFB_4F77FFFE_01 +6FEA335F_4EDFD466_01 +00000800_45000000_00 +FFC07FFF_4F7FC07F_01 +377957FD_4E5DE55F_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +00000AC9_452C9000_00 +00002000_46000000_00 +FFFF8004_4F7FFF80_01 +000BE0DE_493E0DE0_00 +00004000_46800000_00 +3F00001E_4E7C0000_01 +00000400_44800000_00 +00008000_47000000_00 +FF8201FF_4F7F8201_01 +0001D2F1_47E97880_00 +00010000_47800000_00 +0000047E_448FC000_00 +0031B7E5_4A46DF94_00 +00020000_48000000_00 +02200200_4C080080_00 +0213F7E6_4C04FDF9_01 +00040000_48800000_00 +FFFDC007_4F7FFDC0_01 +1D0ABD9A_4DE855EC_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00007CEE_46F9DC00_00 +00100000_49800000_00 +DFDFE000_4F5FDFE0_00 +01FB1642_4BFD8B21_00 +00200000_4A000000_00 +FC000078_4F7C0000_01 +5F70EEC1_4EBEE1DD_01 +00400000_4A800000_00 +00100082_49800410_00 +00000221_44084000_00 +00800000_4B000000_00 +FF7BFF7F_4F7F7BFF_01 +00016393_47B1C980_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFDF_01 +000005B4_44B68000_00 +02000000_4C000000_00 +8002FFFF_4F0002FF_01 +000048E2_4691C400_00 +04000000_4C800000_00 +FFFC0DFE_4F7FFC0D_01 +0000071B_44E36000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF6F_01 +0003092B_48424AC0_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +01B4F3D1_4BDA79E8_01 +20000000_4E000000_00 +FEF801FF_4F7EF801_01 +0000000D_41500000_00 +40000000_4E800000_00 +BFF3FFFE_4F3FF3FF_01 +0009806B_491806B0_00 +80000000_4F000000_00 +0000A07E_47207E00_00 +0000A59F_47259F00_00 +C0000000_4F400000_00 +E0007FDE_4F60007F_01 +0000343E_4650F800_00 +E0000000_4F600000_00 +0000FF7C_477F7C00_00 +00000007_40E00000_00 +F0000000_4F700000_00 +BDFFFFFC_4F3DFFFF_01 +0001E3C1_47F1E080_00 +F8000000_4F780000_00 +28003FFE_4E2000FF_01 +00000008_41000000_00 +FC000000_4F7C0000_00 +00EEFFFF_4B6EFFFF_00 +0000BEB0_473EB000_00 +FE000000_4F7E0000_00 +00000F7D_4577D000_00 +0000000F_41700000_00 +FF000000_4F7F0000_00 +0000406D_4680DA00_00 +0000009A_431A0000_00 +FF800000_4F7F8000_00 +203FFFFD_4E00FFFF_01 +0000001A_41D00000_00 +FFC00000_4F7FC000_00 +FFFF007C_4F7FFF00_01 +0000409B_46813600_00 +FFE00000_4F7FE000_00 +00E00FFF_4B600FFF_00 +0000000E_41600000_00 +FFF00000_4F7FF000_00 +00200FFC_4A003FF0_00 +00001714_45B8A000_00 +FFF80000_4F7FF800_00 +F800040E_4F780004_01 +00000113_43898000_00 +FFFC0000_4F7FFC00_00 +F83BFFFF_4F783BFF_01 +0003F584_487D6100_00 +FFFE0000_4F7FFE00_00 +F6FFFBFF_4F76FFFB_01 +00000000_00000000_00 +FFFF0000_4F7FFF00_00 +80003FFD_4F00003F_01 +0000002D_42340000_00 +FFFF8000_4F7FFF80_00 +004001FD_4A8003FA_00 +001D734E_49EB9A70_00 +FFFFC000_4F7FFFC0_00 +006003FE_4AC007FC_00 +019DBAA8_4BCEDD54_00 +FFFFE000_4F7FFFE0_00 +000403EE_48807DC0_00 +08734668_4D073466_01 +FFFFF000_4F7FFFF0_00 +01200002_4B900001_00 +000874A5_49074A50_00 +FFFFF800_4F7FFFF8_00 +00060001_48C00020_00 +00000008_41000000_00 +FFFFFC00_4F7FFFFC_00 +001FFEDD_49FFF6E8_00 +000056DF_46ADBE00_00 +FFFFFE00_4F7FFFFE_00 +EFFFEFFD_4F6FFFEF_01 +02CF5EC6_4C33D7B1_01 +FFFFFF00_4F7FFFFF_00 +1FF00002_4DFF8000_01 +06DB786B_4CDB6F0D_01 +FFFFFF80_4F7FFFFF_01 +F0000FBE_4F70000F_01 +00000019_41C80000_00 +FFFFFFC0_4F7FFFFF_01 +0010801F_498400F8_00 +0003F238_487C8E00_00 +FFFFFFE0_4F7FFFFF_01 +F8000047_4F780000_01 +0006133C_48C26780_00 +FFFFFFF0_4F7FFFFF_01 +003C001F_4A70007C_00 +000009F1_451F1000_00 +FFFFFFF8_4F7FFFFF_01 +FFDFBFFF_4F7FDFBF_01 +015E507F_4BAF283F_01 +FFFFFFFC_4F7FFFFF_01 +037FFFDE_4C5FFFF7_01 +00017C6F_47BE3780_00 +FFFFFFFE_4F7FFFFF_01 +000000FD_437D0000_00 +0000042A_44854000_00 +FFFFFFFF_4F7FFFFF_01 +021FFF7D_4C07FFDF_01 +0000002A_42280000_00 +FFFFFFFD_4F7FFFFF_01 +4010FFFF_4E8021FF_01 +00000013_41980000_00 +FFFFFFFB_4F7FFFFF_01 +FFFF800B_4F7FFF80_01 +000004B8_44970000_00 +FFFFFFF7_4F7FFFFF_01 +FF800803_4F7F8008_01 +00000006_40C00000_00 +FFFFFFEF_4F7FFFFF_01 +00803FFB_4B003FFB_00 +00000708_44E10000_00 +FFFFFFDF_4F7FFFFF_01 +2107FFFE_4E041FFF_01 +00215D4F_4A05753C_00 +FFFFFFBF_4F7FFFFF_01 +400087FD_4E80010F_01 +0000001F_41F80000_00 +FFFFFF7F_4F7FFFFF_01 +FDFC007E_4F7DFC00_01 +0000000E_41600000_00 +FFFFFEFF_4F7FFFFE_01 +FFF80100_4F7FF801_00 +00000699_44D32000_00 +FFFFFDFF_4F7FFFFD_01 +03000002_4C400000_01 +000716EA_48E2DD40_00 +FFFFFBFF_4F7FFFFB_01 +C7FDFFFF_4F47FDFF_01 +00000327_4449C000_00 +FFFFF7FF_4F7FFFF7_01 +0103DFFE_4B81EFFF_00 +47661FD8_4E8ECC3F_01 +FFFFEFFF_4F7FFFEF_01 +83FFFFFE_4F03FFFF_01 +0CD956DB_4D4D956D_01 +FFFFDFFF_4F7FFFDF_01 +FF2001FD_4F7F2001_01 +04D35BBF_4C9A6B77_01 +FFFFBFFF_4F7FFFBF_01 +DFEFEFFE_4F5FEFEF_01 +15DA4300_4DAED218_00 +FFFF7FFF_4F7FFF7F_01 +40001040_4E800020_01 +812EDF40_4F012EDF_01 +FFFEFFFF_4F7FFEFF_01 +FFFFC007_4F7FFFC0_01 +08B6FCC9_4D0B6FCC_01 +FFFDFFFF_4F7FFDFF_01 +000007FE_44FFC000_00 +003DE950_4A77A540_00 +FFFBFFFF_4F7FFBFF_01 +7FFFFE03_4EFFFFFC_01 +02B02B59_4C2C0AD6_01 +FFF7FFFF_4F7FF7FF_01 +10FF7FFF_4D87FBFF_01 +00408D5E_4A811ABC_00 +FFEFFFFF_4F7FEFFF_01 +FFFF007E_4F7FFF00_01 +003C2108_4A708420_00 +FFDFFFFF_4F7FDFFF_01 +00FFC001_4B7FC001_00 +001C6B36_49E359B0_00 +FFBFFFFF_4F7FBFFF_01 +FFFF7FFF_4F7FFF7F_01 +0001D055_47E82A80_00 +FF7FFFFF_4F7F7FFF_01 +027BFFFE_4C1EFFFF_01 +013090D0_4B984868_00 +FEFFFFFF_4F7EFFFF_01 +00082040_49020400_00 +000000EE_436E0000_00 +FDFFFFFF_4F7DFFFF_01 +FDFFFF87_4F7DFFFF_01 +14C3764D_4DA61BB2_01 +FBFFFFFF_4F7BFFFF_01 +0006007E_48C00FC0_00 +000003EF_447BC000_00 +F7FFFFFF_4F77FFFF_01 +FFBF7FFE_4F7FBF7F_01 +001C4E5A_49E272D0_00 +EFFFFFFF_4F6FFFFF_01 +FFF97FFD_4F7FF97F_01 +000005D1_44BA2000_00 +DFFFFFFF_4F5FFFFF_01 +2FFFFFFE_4E3FFFFF_01 +00936721_4B136721_00 +BFFFFFFF_4F3FFFFF_01 +00004BFF_4697FE00_00 +00002544_46151000_00 +7FFFFFFF_4EFFFFFF_01 +007FDFFB_4AFFBFF6_00 +0000BD5E_473D5E00_00 +3FFFFFFF_4E7FFFFF_01 +FFBF8003_4F7FBF80_01 +000045D2_468BA400_00 +1FFFFFFF_4DFFFFFF_01 +FFFFFDBF_4F7FFFFD_01 +00000189_43C48000_00 +0FFFFFFF_4D7FFFFF_01 +FFFE6FFE_4F7FFE6F_01 +008672A0_4B0672A0_00 +07FFFFFF_4CFFFFFF_01 +00000107_43838000_00 +0000CA70_474A7000_00 +03FFFFFF_4C7FFFFF_01 +002107FE_4A041FF8_00 +000148E7_47A47380_00 +01FFFFFF_4BFFFFFF_01 +F7FDFFEE_4F77FDFF_01 +00000030_42400000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_4F7FFF01_01 +0010FAEF_4987D778_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000001F5_43FA8000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_4F7FE07F_01 +005AFFFB_4AB5FFF6_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +034613B2_4C5184EC_01 +000FFFFF_497FFFF0_00 +F00005FE_4F700005_01 +000B6402_49364020_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C809FFF_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_4F7FFFFD_01 +000341C6_48507180_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D3_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +00000003_40400000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_4F7E7FDF_01 +0000003D_42740000_00 +00003FFF_467FFC00_00 +DBBFFFFE_4F5BBFFF_01 +00000C04_45404000_00 +00001FFF_45FFF800_00 +FFFFC018_4F7FFFC0_01 +00006853_46D0A600_00 +00000FFF_457FF000_00 +03FE007F_4C7F801F_01 +00000124_43920000_00 +000007FF_44FFE000_00 +FFFFEFBE_4F7FFFEF_01 +000B9AD8_4939AD80_00 +000003FF_447FC000_00 +DFFFFDFE_4F5FFFFD_01 +00000595_44B2A000_00 +000001FF_43FF8000_00 +FDFFFFFF_4F7DFFFF_01 +00000010_41800000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +030EC496_4C43B125_01 +0000007F_42FE0000_00 +B8007FFF_4F38007F_01 +00000112_43890000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +0000002F_423C0000_00 +0000001F_41F80000_00 +FF7FFF02_4F7F7FFF_01 +000002CE_44338000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +00000644_44C88000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +0000B8E7_4738E700_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f32_rne.tv b/wally-pipelined/testbench/fp/ui32_f32_rne.tv new file mode 100644 index 000000000..4e348df90 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f32_rne.tv @@ -0,0 +1,372 @@ +1FEFFFEF_4DFF7FFF_01 +0000448E_46891C00_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00019E14_47CF0A00_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +0000DE38_475E3800_00 +00000002_40000000_00 +FFDFFC02_4F7FDFFC_01 +03794C79_4C5E531E_01 +00000004_40800000_00 +F00FFFFE_4F701000_01 +00010A95_47854A80_00 +00000008_41000000_00 +FFFFF97F_4F7FFFF9_01 +01AE458D_4BD722C6_01 +00000010_41800000_00 +0101001E_4B80800F_00 +69EB4561_4ED3D68B_01 +00000020_42000000_00 +8001FFEE_4F000200_01 +0003DD08_48774200_00 +00000040_42800000_00 +FFF03FF9_4F7FF040_01 +000EDF36_496DF360_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000679_44CF2000_00 +00000100_43800000_00 +BFFFFFEF_4F400000_01 +0000000F_41700000_00 +00000200_44000000_00 +010BFFFD_4B85FFFE_01 +00000590_44B20000_00 +00000400_44800000_00 +F7FFFEFB_4F77FFFF_01 +6FEA335F_4EDFD467_01 +00000800_45000000_00 +FFC07FFF_4F7FC080_01 +377957FD_4E5DE560_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +00000AC9_452C9000_00 +00002000_46000000_00 +FFFF8004_4F7FFF80_01 +000BE0DE_493E0DE0_00 +00004000_46800000_00 +3F00001E_4E7C0000_01 +00000400_44800000_00 +00008000_47000000_00 +FF8201FF_4F7F8202_01 +0001D2F1_47E97880_00 +00010000_47800000_00 +0000047E_448FC000_00 +0031B7E5_4A46DF94_00 +00020000_48000000_00 +02200200_4C080080_00 +0213F7E6_4C04FDFA_01 +00040000_48800000_00 +FFFDC007_4F7FFDC0_01 +1D0ABD9A_4DE855ED_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00007CEE_46F9DC00_00 +00100000_49800000_00 +DFDFE000_4F5FDFE0_00 +01FB1642_4BFD8B21_00 +00200000_4A000000_00 +FC000078_4F7C0000_01 +5F70EEC1_4EBEE1DE_01 +00400000_4A800000_00 +00100082_49800410_00 +00000221_44084000_00 +00800000_4B000000_00 +FF7BFF7F_4F7F7BFF_01 +00016393_47B1C980_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFE0_01 +000005B4_44B68000_00 +02000000_4C000000_00 +8002FFFF_4F000300_01 +000048E2_4691C400_00 +04000000_4C800000_00 +FFFC0DFE_4F7FFC0E_01 +0000071B_44E36000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF70_01 +0003092B_48424AC0_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +01B4F3D1_4BDA79E8_01 +20000000_4E000000_00 +FEF801FF_4F7EF802_01 +0000000D_41500000_00 +40000000_4E800000_00 +BFF3FFFE_4F3FF400_01 +0009806B_491806B0_00 +80000000_4F000000_00 +0000A07E_47207E00_00 +0000A59F_47259F00_00 +C0000000_4F400000_00 +E0007FDE_4F600080_01 +0000343E_4650F800_00 +E0000000_4F600000_00 +0000FF7C_477F7C00_00 +00000007_40E00000_00 +F0000000_4F700000_00 +BDFFFFFC_4F3E0000_01 +0001E3C1_47F1E080_00 +F8000000_4F780000_00 +28003FFE_4E200100_01 +00000008_41000000_00 +FC000000_4F7C0000_00 +00EEFFFF_4B6EFFFF_00 +0000BEB0_473EB000_00 +FE000000_4F7E0000_00 +00000F7D_4577D000_00 +0000000F_41700000_00 +FF000000_4F7F0000_00 +0000406D_4680DA00_00 +0000009A_431A0000_00 +FF800000_4F7F8000_00 +203FFFFD_4E010000_01 +0000001A_41D00000_00 +FFC00000_4F7FC000_00 +FFFF007C_4F7FFF00_01 +0000409B_46813600_00 +FFE00000_4F7FE000_00 +00E00FFF_4B600FFF_00 +0000000E_41600000_00 +FFF00000_4F7FF000_00 +00200FFC_4A003FF0_00 +00001714_45B8A000_00 +FFF80000_4F7FF800_00 +F800040E_4F780004_01 +00000113_43898000_00 +FFFC0000_4F7FFC00_00 +F83BFFFF_4F783C00_01 +0003F584_487D6100_00 +FFFE0000_4F7FFE00_00 +F6FFFBFF_4F76FFFC_01 +00000000_00000000_00 +FFFF0000_4F7FFF00_00 +80003FFD_4F000040_01 +0000002D_42340000_00 +FFFF8000_4F7FFF80_00 +004001FD_4A8003FA_00 +001D734E_49EB9A70_00 +FFFFC000_4F7FFFC0_00 +006003FE_4AC007FC_00 +019DBAA8_4BCEDD54_00 +FFFFE000_4F7FFFE0_00 +000403EE_48807DC0_00 +08734668_4D073466_01 +FFFFF000_4F7FFFF0_00 +01200002_4B900001_00 +000874A5_49074A50_00 +FFFFF800_4F7FFFF8_00 +00060001_48C00020_00 +00000008_41000000_00 +FFFFFC00_4F7FFFFC_00 +001FFEDD_49FFF6E8_00 +000056DF_46ADBE00_00 +FFFFFE00_4F7FFFFE_00 +EFFFEFFD_4F6FFFF0_01 +02CF5EC6_4C33D7B2_01 +FFFFFF00_4F7FFFFF_00 +1FF00002_4DFF8000_01 +06DB786B_4CDB6F0D_01 +FFFFFF80_4F800000_01 +F0000FBE_4F700010_01 +00000019_41C80000_00 +FFFFFFC0_4F800000_01 +0010801F_498400F8_00 +0003F238_487C8E00_00 +FFFFFFE0_4F800000_01 +F8000047_4F780000_01 +0006133C_48C26780_00 +FFFFFFF0_4F800000_01 +003C001F_4A70007C_00 +000009F1_451F1000_00 +FFFFFFF8_4F800000_01 +FFDFBFFF_4F7FDFC0_01 +015E507F_4BAF2840_01 +FFFFFFFC_4F800000_01 +037FFFDE_4C5FFFF8_01 +00017C6F_47BE3780_00 +FFFFFFFE_4F800000_01 +000000FD_437D0000_00 +0000042A_44854000_00 +FFFFFFFF_4F800000_01 +021FFF7D_4C07FFDF_01 +0000002A_42280000_00 +FFFFFFFD_4F800000_01 +4010FFFF_4E802200_01 +00000013_41980000_00 +FFFFFFFB_4F800000_01 +FFFF800B_4F7FFF80_01 +000004B8_44970000_00 +FFFFFFF7_4F800000_01 +FF800803_4F7F8008_01 +00000006_40C00000_00 +FFFFFFEF_4F800000_01 +00803FFB_4B003FFB_00 +00000708_44E10000_00 +FFFFFFDF_4F800000_01 +2107FFFE_4E042000_01 +00215D4F_4A05753C_00 +FFFFFFBF_4F800000_01 +400087FD_4E800110_01 +0000001F_41F80000_00 +FFFFFF7F_4F7FFFFF_01 +FDFC007E_4F7DFC00_01 +0000000E_41600000_00 +FFFFFEFF_4F7FFFFF_01 +FFF80100_4F7FF801_00 +00000699_44D32000_00 +FFFFFDFF_4F7FFFFE_01 +03000002_4C400000_01 +000716EA_48E2DD40_00 +FFFFFBFF_4F7FFFFC_01 +C7FDFFFF_4F47FE00_01 +00000327_4449C000_00 +FFFFF7FF_4F7FFFF8_01 +0103DFFE_4B81EFFF_00 +47661FD8_4E8ECC40_01 +FFFFEFFF_4F7FFFF0_01 +83FFFFFE_4F040000_01 +0CD956DB_4D4D956E_01 +FFFFDFFF_4F7FFFE0_01 +FF2001FD_4F7F2002_01 +04D35BBF_4C9A6B78_01 +FFFFBFFF_4F7FFFC0_01 +DFEFEFFE_4F5FEFF0_01 +15DA4300_4DAED218_00 +FFFF7FFF_4F7FFF80_01 +40001040_4E800020_01 +812EDF40_4F012EDF_01 +FFFEFFFF_4F7FFF00_01 +FFFFC007_4F7FFFC0_01 +08B6FCC9_4D0B6FCD_01 +FFFDFFFF_4F7FFE00_01 +000007FE_44FFC000_00 +003DE950_4A77A540_00 +FFFBFFFF_4F7FFC00_01 +7FFFFE03_4EFFFFFC_01 +02B02B59_4C2C0AD6_01 +FFF7FFFF_4F7FF800_01 +10FF7FFF_4D87FC00_01 +00408D5E_4A811ABC_00 +FFEFFFFF_4F7FF000_01 +FFFF007E_4F7FFF00_01 +003C2108_4A708420_00 +FFDFFFFF_4F7FE000_01 +00FFC001_4B7FC001_00 +001C6B36_49E359B0_00 +FFBFFFFF_4F7FC000_01 +FFFF7FFF_4F7FFF80_01 +0001D055_47E82A80_00 +FF7FFFFF_4F7F8000_01 +027BFFFE_4C1F0000_01 +013090D0_4B984868_00 +FEFFFFFF_4F7F0000_01 +00082040_49020400_00 +000000EE_436E0000_00 +FDFFFFFF_4F7E0000_01 +FDFFFF87_4F7E0000_01 +14C3764D_4DA61BB2_01 +FBFFFFFF_4F7C0000_01 +0006007E_48C00FC0_00 +000003EF_447BC000_00 +F7FFFFFF_4F780000_01 +FFBF7FFE_4F7FBF80_01 +001C4E5A_49E272D0_00 +EFFFFFFF_4F700000_01 +FFF97FFD_4F7FF980_01 +000005D1_44BA2000_00 +DFFFFFFF_4F600000_01 +2FFFFFFE_4E400000_01 +00936721_4B136721_00 +BFFFFFFF_4F400000_01 +00004BFF_4697FE00_00 +00002544_46151000_00 +7FFFFFFF_4F000000_01 +007FDFFB_4AFFBFF6_00 +0000BD5E_473D5E00_00 +3FFFFFFF_4E800000_01 +FFBF8003_4F7FBF80_01 +000045D2_468BA400_00 +1FFFFFFF_4E000000_01 +FFFFFDBF_4F7FFFFE_01 +00000189_43C48000_00 +0FFFFFFF_4D800000_01 +FFFE6FFE_4F7FFE70_01 +008672A0_4B0672A0_00 +07FFFFFF_4D000000_01 +00000107_43838000_00 +0000CA70_474A7000_00 +03FFFFFF_4C800000_01 +002107FE_4A041FF8_00 +000148E7_47A47380_00 +01FFFFFF_4C000000_01 +F7FDFFEE_4F77FE00_01 +00000030_42400000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_4F7FFF02_01 +0010FAEF_4987D778_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000001F5_43FA8000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_4F7FE080_01 +005AFFFB_4AB5FFF6_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +034613B2_4C5184EC_01 +000FFFFF_497FFFF0_00 +F00005FE_4F700006_01 +000B6402_49364020_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C80A000_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_4F7FFFFD_01 +000341C6_48507180_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D3_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +00000003_40400000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_4F7E7FE0_01 +0000003D_42740000_00 +00003FFF_467FFC00_00 +DBBFFFFE_4F5BC000_01 +00000C04_45404000_00 +00001FFF_45FFF800_00 +FFFFC018_4F7FFFC0_01 +00006853_46D0A600_00 +00000FFF_457FF000_00 +03FE007F_4C7F8020_01 +00000124_43920000_00 +000007FF_44FFE000_00 +FFFFEFBE_4F7FFFF0_01 +000B9AD8_4939AD80_00 +000003FF_447FC000_00 +DFFFFDFE_4F5FFFFE_01 +00000595_44B2A000_00 +000001FF_43FF8000_00 +FDFFFFFF_4F7E0000_01 +00000010_41800000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +030EC496_4C43B126_01 +0000007F_42FE0000_00 +B8007FFF_4F380080_01 +00000112_43890000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +0000002F_423C0000_00 +0000001F_41F80000_00 +FF7FFF02_4F7F7FFF_01 +000002CE_44338000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +00000644_44C88000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +0000B8E7_4738E700_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f32_ru.tv b/wally-pipelined/testbench/fp/ui32_f32_ru.tv new file mode 100644 index 000000000..788b82ff0 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f32_ru.tv @@ -0,0 +1,372 @@ +1FEFFFEF_4DFF8000_01 +0000448E_46891C00_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00019E14_47CF0A00_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +0000DE38_475E3800_00 +00000002_40000000_00 +FFDFFC02_4F7FDFFD_01 +03794C79_4C5E531F_01 +00000004_40800000_00 +F00FFFFE_4F701000_01 +00010A95_47854A80_00 +00000008_41000000_00 +FFFFF97F_4F7FFFFA_01 +01AE458D_4BD722C7_01 +00000010_41800000_00 +0101001E_4B80800F_00 +69EB4561_4ED3D68B_01 +00000020_42000000_00 +8001FFEE_4F000200_01 +0003DD08_48774200_00 +00000040_42800000_00 +FFF03FF9_4F7FF040_01 +000EDF36_496DF360_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000679_44CF2000_00 +00000100_43800000_00 +BFFFFFEF_4F400000_01 +0000000F_41700000_00 +00000200_44000000_00 +010BFFFD_4B85FFFF_01 +00000590_44B20000_00 +00000400_44800000_00 +F7FFFEFB_4F77FFFF_01 +6FEA335F_4EDFD467_01 +00000800_45000000_00 +FFC07FFF_4F7FC080_01 +377957FD_4E5DE560_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +00000AC9_452C9000_00 +00002000_46000000_00 +FFFF8004_4F7FFF81_01 +000BE0DE_493E0DE0_00 +00004000_46800000_00 +3F00001E_4E7C0001_01 +00000400_44800000_00 +00008000_47000000_00 +FF8201FF_4F7F8202_01 +0001D2F1_47E97880_00 +00010000_47800000_00 +0000047E_448FC000_00 +0031B7E5_4A46DF94_00 +00020000_48000000_00 +02200200_4C080080_00 +0213F7E6_4C04FDFA_01 +00040000_48800000_00 +FFFDC007_4F7FFDC1_01 +1D0ABD9A_4DE855ED_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00007CEE_46F9DC00_00 +00100000_49800000_00 +DFDFE000_4F5FDFE0_00 +01FB1642_4BFD8B21_00 +00200000_4A000000_00 +FC000078_4F7C0001_01 +5F70EEC1_4EBEE1DE_01 +00400000_4A800000_00 +00100082_49800410_00 +00000221_44084000_00 +00800000_4B000000_00 +FF7BFF7F_4F7F7C00_01 +00016393_47B1C980_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFE0_01 +000005B4_44B68000_00 +02000000_4C000000_00 +8002FFFF_4F000300_01 +000048E2_4691C400_00 +04000000_4C800000_00 +FFFC0DFE_4F7FFC0E_01 +0000071B_44E36000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF70_01 +0003092B_48424AC0_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +01B4F3D1_4BDA79E9_01 +20000000_4E000000_00 +FEF801FF_4F7EF802_01 +0000000D_41500000_00 +40000000_4E800000_00 +BFF3FFFE_4F3FF400_01 +0009806B_491806B0_00 +80000000_4F000000_00 +0000A07E_47207E00_00 +0000A59F_47259F00_00 +C0000000_4F400000_00 +E0007FDE_4F600080_01 +0000343E_4650F800_00 +E0000000_4F600000_00 +0000FF7C_477F7C00_00 +00000007_40E00000_00 +F0000000_4F700000_00 +BDFFFFFC_4F3E0000_01 +0001E3C1_47F1E080_00 +F8000000_4F780000_00 +28003FFE_4E200100_01 +00000008_41000000_00 +FC000000_4F7C0000_00 +00EEFFFF_4B6EFFFF_00 +0000BEB0_473EB000_00 +FE000000_4F7E0000_00 +00000F7D_4577D000_00 +0000000F_41700000_00 +FF000000_4F7F0000_00 +0000406D_4680DA00_00 +0000009A_431A0000_00 +FF800000_4F7F8000_00 +203FFFFD_4E010000_01 +0000001A_41D00000_00 +FFC00000_4F7FC000_00 +FFFF007C_4F7FFF01_01 +0000409B_46813600_00 +FFE00000_4F7FE000_00 +00E00FFF_4B600FFF_00 +0000000E_41600000_00 +FFF00000_4F7FF000_00 +00200FFC_4A003FF0_00 +00001714_45B8A000_00 +FFF80000_4F7FF800_00 +F800040E_4F780005_01 +00000113_43898000_00 +FFFC0000_4F7FFC00_00 +F83BFFFF_4F783C00_01 +0003F584_487D6100_00 +FFFE0000_4F7FFE00_00 +F6FFFBFF_4F76FFFC_01 +00000000_00000000_00 +FFFF0000_4F7FFF00_00 +80003FFD_4F000040_01 +0000002D_42340000_00 +FFFF8000_4F7FFF80_00 +004001FD_4A8003FA_00 +001D734E_49EB9A70_00 +FFFFC000_4F7FFFC0_00 +006003FE_4AC007FC_00 +019DBAA8_4BCEDD54_00 +FFFFE000_4F7FFFE0_00 +000403EE_48807DC0_00 +08734668_4D073467_01 +FFFFF000_4F7FFFF0_00 +01200002_4B900001_00 +000874A5_49074A50_00 +FFFFF800_4F7FFFF8_00 +00060001_48C00020_00 +00000008_41000000_00 +FFFFFC00_4F7FFFFC_00 +001FFEDD_49FFF6E8_00 +000056DF_46ADBE00_00 +FFFFFE00_4F7FFFFE_00 +EFFFEFFD_4F6FFFF0_01 +02CF5EC6_4C33D7B2_01 +FFFFFF00_4F7FFFFF_00 +1FF00002_4DFF8001_01 +06DB786B_4CDB6F0E_01 +FFFFFF80_4F800000_01 +F0000FBE_4F700010_01 +00000019_41C80000_00 +FFFFFFC0_4F800000_01 +0010801F_498400F8_00 +0003F238_487C8E00_00 +FFFFFFE0_4F800000_01 +F8000047_4F780001_01 +0006133C_48C26780_00 +FFFFFFF0_4F800000_01 +003C001F_4A70007C_00 +000009F1_451F1000_00 +FFFFFFF8_4F800000_01 +FFDFBFFF_4F7FDFC0_01 +015E507F_4BAF2840_01 +FFFFFFFC_4F800000_01 +037FFFDE_4C5FFFF8_01 +00017C6F_47BE3780_00 +FFFFFFFE_4F800000_01 +000000FD_437D0000_00 +0000042A_44854000_00 +FFFFFFFF_4F800000_01 +021FFF7D_4C07FFE0_01 +0000002A_42280000_00 +FFFFFFFD_4F800000_01 +4010FFFF_4E802200_01 +00000013_41980000_00 +FFFFFFFB_4F800000_01 +FFFF800B_4F7FFF81_01 +000004B8_44970000_00 +FFFFFFF7_4F800000_01 +FF800803_4F7F8009_01 +00000006_40C00000_00 +FFFFFFEF_4F800000_01 +00803FFB_4B003FFB_00 +00000708_44E10000_00 +FFFFFFDF_4F800000_01 +2107FFFE_4E042000_01 +00215D4F_4A05753C_00 +FFFFFFBF_4F800000_01 +400087FD_4E800110_01 +0000001F_41F80000_00 +FFFFFF7F_4F800000_01 +FDFC007E_4F7DFC01_01 +0000000E_41600000_00 +FFFFFEFF_4F7FFFFF_01 +FFF80100_4F7FF801_00 +00000699_44D32000_00 +FFFFFDFF_4F7FFFFE_01 +03000002_4C400001_01 +000716EA_48E2DD40_00 +FFFFFBFF_4F7FFFFC_01 +C7FDFFFF_4F47FE00_01 +00000327_4449C000_00 +FFFFF7FF_4F7FFFF8_01 +0103DFFE_4B81EFFF_00 +47661FD8_4E8ECC40_01 +FFFFEFFF_4F7FFFF0_01 +83FFFFFE_4F040000_01 +0CD956DB_4D4D956E_01 +FFFFDFFF_4F7FFFE0_01 +FF2001FD_4F7F2002_01 +04D35BBF_4C9A6B78_01 +FFFFBFFF_4F7FFFC0_01 +DFEFEFFE_4F5FEFF0_01 +15DA4300_4DAED218_00 +FFFF7FFF_4F7FFF80_01 +40001040_4E800021_01 +812EDF40_4F012EE0_01 +FFFEFFFF_4F7FFF00_01 +FFFFC007_4F7FFFC1_01 +08B6FCC9_4D0B6FCD_01 +FFFDFFFF_4F7FFE00_01 +000007FE_44FFC000_00 +003DE950_4A77A540_00 +FFFBFFFF_4F7FFC00_01 +7FFFFE03_4EFFFFFD_01 +02B02B59_4C2C0AD7_01 +FFF7FFFF_4F7FF800_01 +10FF7FFF_4D87FC00_01 +00408D5E_4A811ABC_00 +FFEFFFFF_4F7FF000_01 +FFFF007E_4F7FFF01_01 +003C2108_4A708420_00 +FFDFFFFF_4F7FE000_01 +00FFC001_4B7FC001_00 +001C6B36_49E359B0_00 +FFBFFFFF_4F7FC000_01 +FFFF7FFF_4F7FFF80_01 +0001D055_47E82A80_00 +FF7FFFFF_4F7F8000_01 +027BFFFE_4C1F0000_01 +013090D0_4B984868_00 +FEFFFFFF_4F7F0000_01 +00082040_49020400_00 +000000EE_436E0000_00 +FDFFFFFF_4F7E0000_01 +FDFFFF87_4F7E0000_01 +14C3764D_4DA61BB3_01 +FBFFFFFF_4F7C0000_01 +0006007E_48C00FC0_00 +000003EF_447BC000_00 +F7FFFFFF_4F780000_01 +FFBF7FFE_4F7FBF80_01 +001C4E5A_49E272D0_00 +EFFFFFFF_4F700000_01 +FFF97FFD_4F7FF980_01 +000005D1_44BA2000_00 +DFFFFFFF_4F600000_01 +2FFFFFFE_4E400000_01 +00936721_4B136721_00 +BFFFFFFF_4F400000_01 +00004BFF_4697FE00_00 +00002544_46151000_00 +7FFFFFFF_4F000000_01 +007FDFFB_4AFFBFF6_00 +0000BD5E_473D5E00_00 +3FFFFFFF_4E800000_01 +FFBF8003_4F7FBF81_01 +000045D2_468BA400_00 +1FFFFFFF_4E000000_01 +FFFFFDBF_4F7FFFFE_01 +00000189_43C48000_00 +0FFFFFFF_4D800000_01 +FFFE6FFE_4F7FFE70_01 +008672A0_4B0672A0_00 +07FFFFFF_4D000000_01 +00000107_43838000_00 +0000CA70_474A7000_00 +03FFFFFF_4C800000_01 +002107FE_4A041FF8_00 +000148E7_47A47380_00 +01FFFFFF_4C000000_01 +F7FDFFEE_4F77FE00_01 +00000030_42400000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_4F7FFF02_01 +0010FAEF_4987D778_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000001F5_43FA8000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_4F7FE080_01 +005AFFFB_4AB5FFF6_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +034613B2_4C5184ED_01 +000FFFFF_497FFFF0_00 +F00005FE_4F700006_01 +000B6402_49364020_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C80A000_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_4F7FFFFE_01 +000341C6_48507180_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D4_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +00000003_40400000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_4F7E7FE0_01 +0000003D_42740000_00 +00003FFF_467FFC00_00 +DBBFFFFE_4F5BC000_01 +00000C04_45404000_00 +00001FFF_45FFF800_00 +FFFFC018_4F7FFFC1_01 +00006853_46D0A600_00 +00000FFF_457FF000_00 +03FE007F_4C7F8020_01 +00000124_43920000_00 +000007FF_44FFE000_00 +FFFFEFBE_4F7FFFF0_01 +000B9AD8_4939AD80_00 +000003FF_447FC000_00 +DFFFFDFE_4F5FFFFE_01 +00000595_44B2A000_00 +000001FF_43FF8000_00 +FDFFFFFF_4F7E0000_01 +00000010_41800000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +030EC496_4C43B126_01 +0000007F_42FE0000_00 +B8007FFF_4F380080_01 +00000112_43890000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +0000002F_423C0000_00 +0000001F_41F80000_00 +FF7FFF02_4F7F8000_01 +000002CE_44338000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +00000644_44C88000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +0000B8E7_4738E700_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f32_rz.tv b/wally-pipelined/testbench/fp/ui32_f32_rz.tv new file mode 100644 index 000000000..aa109500c --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f32_rz.tv @@ -0,0 +1,372 @@ +1FEFFFEF_4DFF7FFF_01 +0000448E_46891C00_00 +00000000_00000000_00 +007FFFCD_4AFFFF9A_00 +00019E14_47CF0A00_00 +00000001_3F800000_00 +001FFFFB_49FFFFD8_00 +0000DE38_475E3800_00 +00000002_40000000_00 +FFDFFC02_4F7FDFFC_01 +03794C79_4C5E531E_01 +00000004_40800000_00 +F00FFFFE_4F700FFF_01 +00010A95_47854A80_00 +00000008_41000000_00 +FFFFF97F_4F7FFFF9_01 +01AE458D_4BD722C6_01 +00000010_41800000_00 +0101001E_4B80800F_00 +69EB4561_4ED3D68A_01 +00000020_42000000_00 +8001FFEE_4F0001FF_01 +0003DD08_48774200_00 +00000040_42800000_00 +FFF03FF9_4F7FF03F_01 +000EDF36_496DF360_00 +00000080_43000000_00 +0000F01F_47701F00_00 +00000679_44CF2000_00 +00000100_43800000_00 +BFFFFFEF_4F3FFFFF_01 +0000000F_41700000_00 +00000200_44000000_00 +010BFFFD_4B85FFFE_01 +00000590_44B20000_00 +00000400_44800000_00 +F7FFFEFB_4F77FFFE_01 +6FEA335F_4EDFD466_01 +00000800_45000000_00 +FFC07FFF_4F7FC07F_01 +377957FD_4E5DE55F_01 +00001000_45800000_00 +01FBFFEE_4BFDFFF7_00 +00000AC9_452C9000_00 +00002000_46000000_00 +FFFF8004_4F7FFF80_01 +000BE0DE_493E0DE0_00 +00004000_46800000_00 +3F00001E_4E7C0000_01 +00000400_44800000_00 +00008000_47000000_00 +FF8201FF_4F7F8201_01 +0001D2F1_47E97880_00 +00010000_47800000_00 +0000047E_448FC000_00 +0031B7E5_4A46DF94_00 +00020000_48000000_00 +02200200_4C080080_00 +0213F7E6_4C04FDF9_01 +00040000_48800000_00 +FFFDC007_4F7FFDC0_01 +1D0ABD9A_4DE855EC_01 +00080000_49000000_00 +0000607F_46C0FE00_00 +00007CEE_46F9DC00_00 +00100000_49800000_00 +DFDFE000_4F5FDFE0_00 +01FB1642_4BFD8B21_00 +00200000_4A000000_00 +FC000078_4F7C0000_01 +5F70EEC1_4EBEE1DD_01 +00400000_4A800000_00 +00100082_49800410_00 +00000221_44084000_00 +00800000_4B000000_00 +FF7BFF7F_4F7F7BFF_01 +00016393_47B1C980_00 +01000000_4B800000_00 +07EFFEFD_4CFDFFDF_01 +000005B4_44B68000_00 +02000000_4C000000_00 +8002FFFF_4F0002FF_01 +000048E2_4691C400_00 +04000000_4C800000_00 +FFFC0DFE_4F7FFC0D_01 +0000071B_44E36000_00 +08000000_4D000000_00 +03FFFDBF_4C7FFF6F_01 +0003092B_48424AC0_00 +10000000_4D800000_00 +007FBFFD_4AFF7FFA_00 +01B4F3D1_4BDA79E8_01 +20000000_4E000000_00 +FEF801FF_4F7EF801_01 +0000000D_41500000_00 +40000000_4E800000_00 +BFF3FFFE_4F3FF3FF_01 +0009806B_491806B0_00 +80000000_4F000000_00 +0000A07E_47207E00_00 +0000A59F_47259F00_00 +C0000000_4F400000_00 +E0007FDE_4F60007F_01 +0000343E_4650F800_00 +E0000000_4F600000_00 +0000FF7C_477F7C00_00 +00000007_40E00000_00 +F0000000_4F700000_00 +BDFFFFFC_4F3DFFFF_01 +0001E3C1_47F1E080_00 +F8000000_4F780000_00 +28003FFE_4E2000FF_01 +00000008_41000000_00 +FC000000_4F7C0000_00 +00EEFFFF_4B6EFFFF_00 +0000BEB0_473EB000_00 +FE000000_4F7E0000_00 +00000F7D_4577D000_00 +0000000F_41700000_00 +FF000000_4F7F0000_00 +0000406D_4680DA00_00 +0000009A_431A0000_00 +FF800000_4F7F8000_00 +203FFFFD_4E00FFFF_01 +0000001A_41D00000_00 +FFC00000_4F7FC000_00 +FFFF007C_4F7FFF00_01 +0000409B_46813600_00 +FFE00000_4F7FE000_00 +00E00FFF_4B600FFF_00 +0000000E_41600000_00 +FFF00000_4F7FF000_00 +00200FFC_4A003FF0_00 +00001714_45B8A000_00 +FFF80000_4F7FF800_00 +F800040E_4F780004_01 +00000113_43898000_00 +FFFC0000_4F7FFC00_00 +F83BFFFF_4F783BFF_01 +0003F584_487D6100_00 +FFFE0000_4F7FFE00_00 +F6FFFBFF_4F76FFFB_01 +00000000_00000000_00 +FFFF0000_4F7FFF00_00 +80003FFD_4F00003F_01 +0000002D_42340000_00 +FFFF8000_4F7FFF80_00 +004001FD_4A8003FA_00 +001D734E_49EB9A70_00 +FFFFC000_4F7FFFC0_00 +006003FE_4AC007FC_00 +019DBAA8_4BCEDD54_00 +FFFFE000_4F7FFFE0_00 +000403EE_48807DC0_00 +08734668_4D073466_01 +FFFFF000_4F7FFFF0_00 +01200002_4B900001_00 +000874A5_49074A50_00 +FFFFF800_4F7FFFF8_00 +00060001_48C00020_00 +00000008_41000000_00 +FFFFFC00_4F7FFFFC_00 +001FFEDD_49FFF6E8_00 +000056DF_46ADBE00_00 +FFFFFE00_4F7FFFFE_00 +EFFFEFFD_4F6FFFEF_01 +02CF5EC6_4C33D7B1_01 +FFFFFF00_4F7FFFFF_00 +1FF00002_4DFF8000_01 +06DB786B_4CDB6F0D_01 +FFFFFF80_4F7FFFFF_01 +F0000FBE_4F70000F_01 +00000019_41C80000_00 +FFFFFFC0_4F7FFFFF_01 +0010801F_498400F8_00 +0003F238_487C8E00_00 +FFFFFFE0_4F7FFFFF_01 +F8000047_4F780000_01 +0006133C_48C26780_00 +FFFFFFF0_4F7FFFFF_01 +003C001F_4A70007C_00 +000009F1_451F1000_00 +FFFFFFF8_4F7FFFFF_01 +FFDFBFFF_4F7FDFBF_01 +015E507F_4BAF283F_01 +FFFFFFFC_4F7FFFFF_01 +037FFFDE_4C5FFFF7_01 +00017C6F_47BE3780_00 +FFFFFFFE_4F7FFFFF_01 +000000FD_437D0000_00 +0000042A_44854000_00 +FFFFFFFF_4F7FFFFF_01 +021FFF7D_4C07FFDF_01 +0000002A_42280000_00 +FFFFFFFD_4F7FFFFF_01 +4010FFFF_4E8021FF_01 +00000013_41980000_00 +FFFFFFFB_4F7FFFFF_01 +FFFF800B_4F7FFF80_01 +000004B8_44970000_00 +FFFFFFF7_4F7FFFFF_01 +FF800803_4F7F8008_01 +00000006_40C00000_00 +FFFFFFEF_4F7FFFFF_01 +00803FFB_4B003FFB_00 +00000708_44E10000_00 +FFFFFFDF_4F7FFFFF_01 +2107FFFE_4E041FFF_01 +00215D4F_4A05753C_00 +FFFFFFBF_4F7FFFFF_01 +400087FD_4E80010F_01 +0000001F_41F80000_00 +FFFFFF7F_4F7FFFFF_01 +FDFC007E_4F7DFC00_01 +0000000E_41600000_00 +FFFFFEFF_4F7FFFFE_01 +FFF80100_4F7FF801_00 +00000699_44D32000_00 +FFFFFDFF_4F7FFFFD_01 +03000002_4C400000_01 +000716EA_48E2DD40_00 +FFFFFBFF_4F7FFFFB_01 +C7FDFFFF_4F47FDFF_01 +00000327_4449C000_00 +FFFFF7FF_4F7FFFF7_01 +0103DFFE_4B81EFFF_00 +47661FD8_4E8ECC3F_01 +FFFFEFFF_4F7FFFEF_01 +83FFFFFE_4F03FFFF_01 +0CD956DB_4D4D956D_01 +FFFFDFFF_4F7FFFDF_01 +FF2001FD_4F7F2001_01 +04D35BBF_4C9A6B77_01 +FFFFBFFF_4F7FFFBF_01 +DFEFEFFE_4F5FEFEF_01 +15DA4300_4DAED218_00 +FFFF7FFF_4F7FFF7F_01 +40001040_4E800020_01 +812EDF40_4F012EDF_01 +FFFEFFFF_4F7FFEFF_01 +FFFFC007_4F7FFFC0_01 +08B6FCC9_4D0B6FCC_01 +FFFDFFFF_4F7FFDFF_01 +000007FE_44FFC000_00 +003DE950_4A77A540_00 +FFFBFFFF_4F7FFBFF_01 +7FFFFE03_4EFFFFFC_01 +02B02B59_4C2C0AD6_01 +FFF7FFFF_4F7FF7FF_01 +10FF7FFF_4D87FBFF_01 +00408D5E_4A811ABC_00 +FFEFFFFF_4F7FEFFF_01 +FFFF007E_4F7FFF00_01 +003C2108_4A708420_00 +FFDFFFFF_4F7FDFFF_01 +00FFC001_4B7FC001_00 +001C6B36_49E359B0_00 +FFBFFFFF_4F7FBFFF_01 +FFFF7FFF_4F7FFF7F_01 +0001D055_47E82A80_00 +FF7FFFFF_4F7F7FFF_01 +027BFFFE_4C1EFFFF_01 +013090D0_4B984868_00 +FEFFFFFF_4F7EFFFF_01 +00082040_49020400_00 +000000EE_436E0000_00 +FDFFFFFF_4F7DFFFF_01 +FDFFFF87_4F7DFFFF_01 +14C3764D_4DA61BB2_01 +FBFFFFFF_4F7BFFFF_01 +0006007E_48C00FC0_00 +000003EF_447BC000_00 +F7FFFFFF_4F77FFFF_01 +FFBF7FFE_4F7FBF7F_01 +001C4E5A_49E272D0_00 +EFFFFFFF_4F6FFFFF_01 +FFF97FFD_4F7FF97F_01 +000005D1_44BA2000_00 +DFFFFFFF_4F5FFFFF_01 +2FFFFFFE_4E3FFFFF_01 +00936721_4B136721_00 +BFFFFFFF_4F3FFFFF_01 +00004BFF_4697FE00_00 +00002544_46151000_00 +7FFFFFFF_4EFFFFFF_01 +007FDFFB_4AFFBFF6_00 +0000BD5E_473D5E00_00 +3FFFFFFF_4E7FFFFF_01 +FFBF8003_4F7FBF80_01 +000045D2_468BA400_00 +1FFFFFFF_4DFFFFFF_01 +FFFFFDBF_4F7FFFFD_01 +00000189_43C48000_00 +0FFFFFFF_4D7FFFFF_01 +FFFE6FFE_4F7FFE6F_01 +008672A0_4B0672A0_00 +07FFFFFF_4CFFFFFF_01 +00000107_43838000_00 +0000CA70_474A7000_00 +03FFFFFF_4C7FFFFF_01 +002107FE_4A041FF8_00 +000148E7_47A47380_00 +01FFFFFF_4BFFFFFF_01 +F7FDFFEE_4F77FDFF_01 +00000030_42400000_00 +00FFFFFF_4B7FFFFF_00 +FFFF01FD_4F7FFF01_01 +0010FAEF_4987D778_00 +007FFFFF_4AFFFFFE_00 +00FC0001_4B7C0001_00 +000001F5_43FA8000_00 +003FFFFF_4A7FFFFC_00 +FFE07FC0_4F7FE07F_01 +005AFFFB_4AB5FFF6_00 +001FFFFF_49FFFFF8_00 +00101FFD_4980FFE8_00 +034613B2_4C5184EC_01 +000FFFFF_497FFFF0_00 +F00005FE_4F700005_01 +000B6402_49364020_00 +0007FFFF_48FFFFE0_00 +0404FFFF_4C809FFF_01 +021C2358_4C0708D6_00 +0003FFFF_487FFFC0_00 +FFFFFD02_4F7FFFFD_01 +000341C6_48507180_00 +0001FFFF_47FFFF80_00 +00000007_40E00000_00 +27F174DE_4E1FC5D3_01 +0000FFFF_477FFF00_00 +000083F5_4703F500_00 +00000003_40400000_00 +00007FFF_46FFFE00_00 +FE7FDFFE_4F7E7FDF_01 +0000003D_42740000_00 +00003FFF_467FFC00_00 +DBBFFFFE_4F5BBFFF_01 +00000C04_45404000_00 +00001FFF_45FFF800_00 +FFFFC018_4F7FFFC0_01 +00006853_46D0A600_00 +00000FFF_457FF000_00 +03FE007F_4C7F801F_01 +00000124_43920000_00 +000007FF_44FFE000_00 +FFFFEFBE_4F7FFFEF_01 +000B9AD8_4939AD80_00 +000003FF_447FC000_00 +DFFFFDFE_4F5FFFFD_01 +00000595_44B2A000_00 +000001FF_43FF8000_00 +FDFFFFFF_4F7DFFFF_01 +00000010_41800000_00 +000000FF_437F0000_00 +0037FFE0_4A5FFF80_00 +030EC496_4C43B125_01 +0000007F_42FE0000_00 +B8007FFF_4F38007F_01 +00000112_43890000_00 +0000003F_427C0000_00 +02003FFC_4C000FFF_00 +0000002F_423C0000_00 +0000001F_41F80000_00 +FF7FFF02_4F7F7FFF_01 +000002CE_44338000_00 +0000000F_41700000_00 +0000A00D_47200D00_00 +00000644_44C88000_00 +00000007_40E00000_00 +0003FFFA_487FFE80_00 +0000B8E7_4738E700_00 +00000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f64_rd.tv b/wally-pipelined/testbench/fp/ui32_f64_rd.tv new file mode 100644 index 000000000..ce22e2c74 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f64_rd.tv @@ -0,0 +1,372 @@ +1FEFFFEF_41BFEFFFEF000000_00 +0000448E_40D1238000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00019E14_40F9E14000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +0000DE38_40EBC70000000000_00 +00000002_4000000000000000_00 +FFDFFC02_41EFFBFF80400000_00 +03794C79_418BCA63C8000000_00 +00000004_4010000000000000_00 +F00FFFFE_41EE01FFFFC00000_00 +00010A95_40F0A95000000000_00 +00000008_4020000000000000_00 +FFFFF97F_41EFFFFF2FE00000_00 +01AE458D_417AE458D0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +69EB4561_41DA7AD158400000_00 +00000020_4040000000000000_00 +8001FFEE_41E0003FFDC00000_00 +0003DD08_410EE84000000000_00 +00000040_4050000000000000_00 +FFF03FF9_41EFFE07FF200000_00 +000EDF36_412DBE6C00000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000679_4099E40000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_41E7FFFFFDE00000_00 +0000000F_402E000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +00000590_4096400000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_41EEFFFFDF600000_00 +6FEA335F_41DBFA8CD7C00000_00 +00000800_40A0000000000000_00 +FFC07FFF_41EFF80FFFE00000_00 +377957FD_41CBBCABFE800000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +00000AC9_40A5920000000000_00 +00002000_40C0000000000000_00 +FFFF8004_41EFFFF000800000_00 +000BE0DE_4127C1BC00000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000400_4090000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_41EFF0403FE00000_00 +0001D2F1_40FD2F1000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0031B7E5_4148DBF280000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0213F7E6_41809FBF30000000_00 +00040000_4110000000000000_00 +FFFDC007_41EFFFB800E00000_00 +1D0ABD9A_41BD0ABD9A000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00007CEE_40DF3B8000000000_00 +00100000_4130000000000000_00 +DFDFE000_41EBFBFC00000000_00 +01FB1642_417FB16420000000_00 +00200000_4140000000000000_00 +FC000078_41EF80000F000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +00000221_4081080000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_41EFEF7FEFE00000_00 +00016393_40F6393000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +000005B4_4096D00000000000_00 +02000000_4180000000000000_00 +8002FFFF_41E0005FFFE00000_00 +000048E2_40D2388000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_41EFFF81BFC00000_00 +0000071B_409C6C0000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0003092B_4108495800000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +01B4F3D1_417B4F3D10000000_00 +20000000_41C0000000000000_00 +FEF801FF_41EFDF003FE00000_00 +0000000D_402A000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_41E7FE7FFFC00000_00 +0009806B_412300D600000000_00 +80000000_41E0000000000000_00 +0000A07E_40E40FC000000000_00 +0000A59F_40E4B3E000000000_00 +C0000000_41E8000000000000_00 +E0007FDE_41EC000FFBC00000_00 +0000343E_40CA1F0000000000_00 +E0000000_41EC000000000000_00 +0000FF7C_40EFEF8000000000_00 +00000007_401C000000000000_00 +F0000000_41EE000000000000_00 +BDFFFFFC_41E7BFFFFF800000_00 +0001E3C1_40FE3C1000000000_00 +F8000000_41EF000000000000_00 +28003FFE_41C4001FFF000000_00 +00000008_4020000000000000_00 +FC000000_41EF800000000000_00 +00EEFFFF_416DDFFFE0000000_00 +0000BEB0_40E7D60000000000_00 +FE000000_41EFC00000000000_00 +00000F7D_40AEFA0000000000_00 +0000000F_402E000000000000_00 +FF000000_41EFE00000000000_00 +0000406D_40D01B4000000000_00 +0000009A_4063400000000000_00 +FF800000_41EFF00000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000001A_403A000000000000_00 +FFC00000_41EFF80000000000_00 +FFFF007C_41EFFFE00F800000_00 +0000409B_40D026C000000000_00 +FFE00000_41EFFC0000000000_00 +00E00FFF_416C01FFE0000000_00 +0000000E_402C000000000000_00 +FFF00000_41EFFE0000000000_00 +00200FFC_414007FE00000000_00 +00001714_40B7140000000000_00 +FFF80000_41EFFF0000000000_00 +F800040E_41EF000081C00000_00 +00000113_4071300000000000_00 +FFFC0000_41EFFF8000000000_00 +F83BFFFF_41EF077FFFE00000_00 +0003F584_410FAC2000000000_00 +FFFE0000_41EFFFC000000000_00 +F6FFFBFF_41EEDFFF7FE00000_00 +00000000_0000000000000000_00 +FFFF0000_41EFFFE000000000_00 +80003FFD_41E00007FFA00000_00 +0000002D_4046800000000000_00 +FFFF8000_41EFFFF000000000_00 +004001FD_4150007F40000000_00 +001D734E_413D734E00000000_00 +FFFFC000_41EFFFF800000000_00 +006003FE_415800FF80000000_00 +019DBAA8_4179DBAA80000000_00 +FFFFE000_41EFFFFC00000000_00 +000403EE_41100FB800000000_00 +08734668_41A0E68CD0000000_00 +FFFFF000_41EFFFFE00000000_00 +01200002_4172000020000000_00 +000874A5_4120E94A00000000_00 +FFFFF800_41EFFFFF00000000_00 +00060001_4118000400000000_00 +00000008_4020000000000000_00 +FFFFFC00_41EFFFFF80000000_00 +001FFEDD_413FFEDD00000000_00 +000056DF_40D5B7C000000000_00 +FFFFFE00_41EFFFFFC0000000_00 +EFFFEFFD_41EDFFFDFFA00000_00 +02CF5EC6_41867AF630000000_00 +FFFFFF00_41EFFFFFE0000000_00 +1FF00002_41BFF00002000000_00 +06DB786B_419B6DE1AC000000_00 +FFFFFF80_41EFFFFFF0000000_00 +F0000FBE_41EE0001F7C00000_00 +00000019_4039000000000000_00 +FFFFFFC0_41EFFFFFF8000000_00 +0010801F_4130801F00000000_00 +0003F238_410F91C000000000_00 +FFFFFFE0_41EFFFFFFC000000_00 +F8000047_41EF000008E00000_00 +0006133C_41184CF000000000_00 +FFFFFFF0_41EFFFFFFE000000_00 +003C001F_414E000F80000000_00 +000009F1_40A3E20000000000_00 +FFFFFFF8_41EFFFFFFF000000_00 +FFDFBFFF_41EFFBF7FFE00000_00 +015E507F_4175E507F0000000_00 +FFFFFFFC_41EFFFFFFF800000_00 +037FFFDE_418BFFFEF0000000_00 +00017C6F_40F7C6F000000000_00 +FFFFFFFE_41EFFFFFFFC00000_00 +000000FD_406FA00000000000_00 +0000042A_4090A80000000000_00 +FFFFFFFF_41EFFFFFFFE00000_00 +021FFF7D_4180FFFBE8000000_00 +0000002A_4045000000000000_00 +FFFFFFFD_41EFFFFFFFA00000_00 +4010FFFF_41D0043FFFC00000_00 +00000013_4033000000000000_00 +FFFFFFFB_41EFFFFFFF600000_00 +FFFF800B_41EFFFF001600000_00 +000004B8_4092E00000000000_00 +FFFFFFF7_41EFFFFFFEE00000_00 +FF800803_41EFF00100600000_00 +00000006_4018000000000000_00 +FFFFFFEF_41EFFFFFFDE00000_00 +00803FFB_416007FF60000000_00 +00000708_409C200000000000_00 +FFFFFFDF_41EFFFFFFBE00000_00 +2107FFFE_41C083FFFF000000_00 +00215D4F_4140AEA780000000_00 +FFFFFFBF_41EFFFFFF7E00000_00 +400087FD_41D00021FF400000_00 +0000001F_403F000000000000_00 +FFFFFF7F_41EFFFFFEFE00000_00 +FDFC007E_41EFBF800FC00000_00 +0000000E_402C000000000000_00 +FFFFFEFF_41EFFFFFDFE00000_00 +FFF80100_41EFFF0020000000_00 +00000699_409A640000000000_00 +FFFFFDFF_41EFFFFFBFE00000_00 +03000002_4188000010000000_00 +000716EA_411C5BA800000000_00 +FFFFFBFF_41EFFFFF7FE00000_00 +C7FDFFFF_41E8FFBFFFE00000_00 +00000327_4089380000000000_00 +FFFFF7FF_41EFFFFEFFE00000_00 +0103DFFE_41703DFFE0000000_00 +47661FD8_41D1D987F6000000_00 +FFFFEFFF_41EFFFFDFFE00000_00 +83FFFFFE_41E07FFFFFC00000_00 +0CD956DB_41A9B2ADB6000000_00 +FFFFDFFF_41EFFFFBFFE00000_00 +FF2001FD_41EFE4003FA00000_00 +04D35BBF_41934D6EFC000000_00 +FFFFBFFF_41EFFFF7FFE00000_00 +DFEFEFFE_41EBFDFDFFC00000_00 +15DA4300_41B5DA4300000000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +40001040_41D0000410000000_00 +812EDF40_41E025DBE8000000_00 +FFFEFFFF_41EFFFDFFFE00000_00 +FFFFC007_41EFFFF800E00000_00 +08B6FCC9_41A16DF992000000_00 +FFFDFFFF_41EFFFBFFFE00000_00 +000007FE_409FF80000000000_00 +003DE950_414EF4A800000000_00 +FFFBFFFF_41EFFF7FFFE00000_00 +7FFFFE03_41DFFFFF80C00000_00 +02B02B59_4185815AC8000000_00 +FFF7FFFF_41EFFEFFFFE00000_00 +10FF7FFF_41B0FF7FFF000000_00 +00408D5E_4150235780000000_00 +FFEFFFFF_41EFFDFFFFE00000_00 +FFFF007E_41EFFFE00FC00000_00 +003C2108_414E108400000000_00 +FFDFFFFF_41EFFBFFFFE00000_00 +00FFC001_416FF80020000000_00 +001C6B36_413C6B3600000000_00 +FFBFFFFF_41EFF7FFFFE00000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +0001D055_40FD055000000000_00 +FF7FFFFF_41EFEFFFFFE00000_00 +027BFFFE_4183DFFFF0000000_00 +013090D0_4173090D00000000_00 +FEFFFFFF_41EFDFFFFFE00000_00 +00082040_4120408000000000_00 +000000EE_406DC00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +FDFFFF87_41EFBFFFF0E00000_00 +14C3764D_41B4C3764D000000_00 +FBFFFFFF_41EF7FFFFFE00000_00 +0006007E_411801F800000000_00 +000003EF_408F780000000000_00 +F7FFFFFF_41EEFFFFFFE00000_00 +FFBF7FFE_41EFF7EFFFC00000_00 +001C4E5A_413C4E5A00000000_00 +EFFFFFFF_41EDFFFFFFE00000_00 +FFF97FFD_41EFFF2FFFA00000_00 +000005D1_4097440000000000_00 +DFFFFFFF_41EBFFFFFFE00000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00936721_41626CE420000000_00 +BFFFFFFF_41E7FFFFFFE00000_00 +00004BFF_40D2FFC000000000_00 +00002544_40C2A20000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +0000BD5E_40E7ABC000000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_41EFF7F000600000_00 +000045D2_40D1748000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_41EFFFFFB7E00000_00 +00000189_4078900000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_41EFFFCDFFC00000_00 +008672A0_4160CE5400000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +0000CA70_40E94E0000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +000148E7_40F48E7000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_41EEFFBFFDC00000_00 +00000030_4048000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_41EFFFE03FA00000_00 +0010FAEF_4130FAEF00000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000001F5_407F500000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_41EFFC0FF8000000_00 +005AFFFB_4156BFFEC0000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +034613B2_418A309D90000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_41EE0000BFC00000_00 +000B6402_4126C80400000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_41EFFFFFA0400000_00 +000341C6_410A0E3000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +00000003_4008000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_41EFCFFBFFC00000_00 +0000003D_404E800000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_41EB77FFFFC00000_00 +00000C04_40A8080000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_41EFFFF803000000_00 +00006853_40DA14C000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +00000124_4072400000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_41EFFFFDF7C00000_00 +000B9AD8_412735B000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_41EBFFFFBFC00000_00 +00000595_4096540000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +00000010_4030000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +030EC496_41887624B0000000_00 +0000007F_405FC00000000000_00 +B8007FFF_41E7000FFFE00000_00 +00000112_4071200000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +0000002F_4047800000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_41EFEFFFE0400000_00 +000002CE_4086700000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +00000644_4099100000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +0000B8E7_40E71CE000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f64_rne.tv b/wally-pipelined/testbench/fp/ui32_f64_rne.tv new file mode 100644 index 000000000..ce22e2c74 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f64_rne.tv @@ -0,0 +1,372 @@ +1FEFFFEF_41BFEFFFEF000000_00 +0000448E_40D1238000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00019E14_40F9E14000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +0000DE38_40EBC70000000000_00 +00000002_4000000000000000_00 +FFDFFC02_41EFFBFF80400000_00 +03794C79_418BCA63C8000000_00 +00000004_4010000000000000_00 +F00FFFFE_41EE01FFFFC00000_00 +00010A95_40F0A95000000000_00 +00000008_4020000000000000_00 +FFFFF97F_41EFFFFF2FE00000_00 +01AE458D_417AE458D0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +69EB4561_41DA7AD158400000_00 +00000020_4040000000000000_00 +8001FFEE_41E0003FFDC00000_00 +0003DD08_410EE84000000000_00 +00000040_4050000000000000_00 +FFF03FF9_41EFFE07FF200000_00 +000EDF36_412DBE6C00000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000679_4099E40000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_41E7FFFFFDE00000_00 +0000000F_402E000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +00000590_4096400000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_41EEFFFFDF600000_00 +6FEA335F_41DBFA8CD7C00000_00 +00000800_40A0000000000000_00 +FFC07FFF_41EFF80FFFE00000_00 +377957FD_41CBBCABFE800000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +00000AC9_40A5920000000000_00 +00002000_40C0000000000000_00 +FFFF8004_41EFFFF000800000_00 +000BE0DE_4127C1BC00000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000400_4090000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_41EFF0403FE00000_00 +0001D2F1_40FD2F1000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0031B7E5_4148DBF280000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0213F7E6_41809FBF30000000_00 +00040000_4110000000000000_00 +FFFDC007_41EFFFB800E00000_00 +1D0ABD9A_41BD0ABD9A000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00007CEE_40DF3B8000000000_00 +00100000_4130000000000000_00 +DFDFE000_41EBFBFC00000000_00 +01FB1642_417FB16420000000_00 +00200000_4140000000000000_00 +FC000078_41EF80000F000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +00000221_4081080000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_41EFEF7FEFE00000_00 +00016393_40F6393000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +000005B4_4096D00000000000_00 +02000000_4180000000000000_00 +8002FFFF_41E0005FFFE00000_00 +000048E2_40D2388000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_41EFFF81BFC00000_00 +0000071B_409C6C0000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0003092B_4108495800000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +01B4F3D1_417B4F3D10000000_00 +20000000_41C0000000000000_00 +FEF801FF_41EFDF003FE00000_00 +0000000D_402A000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_41E7FE7FFFC00000_00 +0009806B_412300D600000000_00 +80000000_41E0000000000000_00 +0000A07E_40E40FC000000000_00 +0000A59F_40E4B3E000000000_00 +C0000000_41E8000000000000_00 +E0007FDE_41EC000FFBC00000_00 +0000343E_40CA1F0000000000_00 +E0000000_41EC000000000000_00 +0000FF7C_40EFEF8000000000_00 +00000007_401C000000000000_00 +F0000000_41EE000000000000_00 +BDFFFFFC_41E7BFFFFF800000_00 +0001E3C1_40FE3C1000000000_00 +F8000000_41EF000000000000_00 +28003FFE_41C4001FFF000000_00 +00000008_4020000000000000_00 +FC000000_41EF800000000000_00 +00EEFFFF_416DDFFFE0000000_00 +0000BEB0_40E7D60000000000_00 +FE000000_41EFC00000000000_00 +00000F7D_40AEFA0000000000_00 +0000000F_402E000000000000_00 +FF000000_41EFE00000000000_00 +0000406D_40D01B4000000000_00 +0000009A_4063400000000000_00 +FF800000_41EFF00000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000001A_403A000000000000_00 +FFC00000_41EFF80000000000_00 +FFFF007C_41EFFFE00F800000_00 +0000409B_40D026C000000000_00 +FFE00000_41EFFC0000000000_00 +00E00FFF_416C01FFE0000000_00 +0000000E_402C000000000000_00 +FFF00000_41EFFE0000000000_00 +00200FFC_414007FE00000000_00 +00001714_40B7140000000000_00 +FFF80000_41EFFF0000000000_00 +F800040E_41EF000081C00000_00 +00000113_4071300000000000_00 +FFFC0000_41EFFF8000000000_00 +F83BFFFF_41EF077FFFE00000_00 +0003F584_410FAC2000000000_00 +FFFE0000_41EFFFC000000000_00 +F6FFFBFF_41EEDFFF7FE00000_00 +00000000_0000000000000000_00 +FFFF0000_41EFFFE000000000_00 +80003FFD_41E00007FFA00000_00 +0000002D_4046800000000000_00 +FFFF8000_41EFFFF000000000_00 +004001FD_4150007F40000000_00 +001D734E_413D734E00000000_00 +FFFFC000_41EFFFF800000000_00 +006003FE_415800FF80000000_00 +019DBAA8_4179DBAA80000000_00 +FFFFE000_41EFFFFC00000000_00 +000403EE_41100FB800000000_00 +08734668_41A0E68CD0000000_00 +FFFFF000_41EFFFFE00000000_00 +01200002_4172000020000000_00 +000874A5_4120E94A00000000_00 +FFFFF800_41EFFFFF00000000_00 +00060001_4118000400000000_00 +00000008_4020000000000000_00 +FFFFFC00_41EFFFFF80000000_00 +001FFEDD_413FFEDD00000000_00 +000056DF_40D5B7C000000000_00 +FFFFFE00_41EFFFFFC0000000_00 +EFFFEFFD_41EDFFFDFFA00000_00 +02CF5EC6_41867AF630000000_00 +FFFFFF00_41EFFFFFE0000000_00 +1FF00002_41BFF00002000000_00 +06DB786B_419B6DE1AC000000_00 +FFFFFF80_41EFFFFFF0000000_00 +F0000FBE_41EE0001F7C00000_00 +00000019_4039000000000000_00 +FFFFFFC0_41EFFFFFF8000000_00 +0010801F_4130801F00000000_00 +0003F238_410F91C000000000_00 +FFFFFFE0_41EFFFFFFC000000_00 +F8000047_41EF000008E00000_00 +0006133C_41184CF000000000_00 +FFFFFFF0_41EFFFFFFE000000_00 +003C001F_414E000F80000000_00 +000009F1_40A3E20000000000_00 +FFFFFFF8_41EFFFFFFF000000_00 +FFDFBFFF_41EFFBF7FFE00000_00 +015E507F_4175E507F0000000_00 +FFFFFFFC_41EFFFFFFF800000_00 +037FFFDE_418BFFFEF0000000_00 +00017C6F_40F7C6F000000000_00 +FFFFFFFE_41EFFFFFFFC00000_00 +000000FD_406FA00000000000_00 +0000042A_4090A80000000000_00 +FFFFFFFF_41EFFFFFFFE00000_00 +021FFF7D_4180FFFBE8000000_00 +0000002A_4045000000000000_00 +FFFFFFFD_41EFFFFFFFA00000_00 +4010FFFF_41D0043FFFC00000_00 +00000013_4033000000000000_00 +FFFFFFFB_41EFFFFFFF600000_00 +FFFF800B_41EFFFF001600000_00 +000004B8_4092E00000000000_00 +FFFFFFF7_41EFFFFFFEE00000_00 +FF800803_41EFF00100600000_00 +00000006_4018000000000000_00 +FFFFFFEF_41EFFFFFFDE00000_00 +00803FFB_416007FF60000000_00 +00000708_409C200000000000_00 +FFFFFFDF_41EFFFFFFBE00000_00 +2107FFFE_41C083FFFF000000_00 +00215D4F_4140AEA780000000_00 +FFFFFFBF_41EFFFFFF7E00000_00 +400087FD_41D00021FF400000_00 +0000001F_403F000000000000_00 +FFFFFF7F_41EFFFFFEFE00000_00 +FDFC007E_41EFBF800FC00000_00 +0000000E_402C000000000000_00 +FFFFFEFF_41EFFFFFDFE00000_00 +FFF80100_41EFFF0020000000_00 +00000699_409A640000000000_00 +FFFFFDFF_41EFFFFFBFE00000_00 +03000002_4188000010000000_00 +000716EA_411C5BA800000000_00 +FFFFFBFF_41EFFFFF7FE00000_00 +C7FDFFFF_41E8FFBFFFE00000_00 +00000327_4089380000000000_00 +FFFFF7FF_41EFFFFEFFE00000_00 +0103DFFE_41703DFFE0000000_00 +47661FD8_41D1D987F6000000_00 +FFFFEFFF_41EFFFFDFFE00000_00 +83FFFFFE_41E07FFFFFC00000_00 +0CD956DB_41A9B2ADB6000000_00 +FFFFDFFF_41EFFFFBFFE00000_00 +FF2001FD_41EFE4003FA00000_00 +04D35BBF_41934D6EFC000000_00 +FFFFBFFF_41EFFFF7FFE00000_00 +DFEFEFFE_41EBFDFDFFC00000_00 +15DA4300_41B5DA4300000000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +40001040_41D0000410000000_00 +812EDF40_41E025DBE8000000_00 +FFFEFFFF_41EFFFDFFFE00000_00 +FFFFC007_41EFFFF800E00000_00 +08B6FCC9_41A16DF992000000_00 +FFFDFFFF_41EFFFBFFFE00000_00 +000007FE_409FF80000000000_00 +003DE950_414EF4A800000000_00 +FFFBFFFF_41EFFF7FFFE00000_00 +7FFFFE03_41DFFFFF80C00000_00 +02B02B59_4185815AC8000000_00 +FFF7FFFF_41EFFEFFFFE00000_00 +10FF7FFF_41B0FF7FFF000000_00 +00408D5E_4150235780000000_00 +FFEFFFFF_41EFFDFFFFE00000_00 +FFFF007E_41EFFFE00FC00000_00 +003C2108_414E108400000000_00 +FFDFFFFF_41EFFBFFFFE00000_00 +00FFC001_416FF80020000000_00 +001C6B36_413C6B3600000000_00 +FFBFFFFF_41EFF7FFFFE00000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +0001D055_40FD055000000000_00 +FF7FFFFF_41EFEFFFFFE00000_00 +027BFFFE_4183DFFFF0000000_00 +013090D0_4173090D00000000_00 +FEFFFFFF_41EFDFFFFFE00000_00 +00082040_4120408000000000_00 +000000EE_406DC00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +FDFFFF87_41EFBFFFF0E00000_00 +14C3764D_41B4C3764D000000_00 +FBFFFFFF_41EF7FFFFFE00000_00 +0006007E_411801F800000000_00 +000003EF_408F780000000000_00 +F7FFFFFF_41EEFFFFFFE00000_00 +FFBF7FFE_41EFF7EFFFC00000_00 +001C4E5A_413C4E5A00000000_00 +EFFFFFFF_41EDFFFFFFE00000_00 +FFF97FFD_41EFFF2FFFA00000_00 +000005D1_4097440000000000_00 +DFFFFFFF_41EBFFFFFFE00000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00936721_41626CE420000000_00 +BFFFFFFF_41E7FFFFFFE00000_00 +00004BFF_40D2FFC000000000_00 +00002544_40C2A20000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +0000BD5E_40E7ABC000000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_41EFF7F000600000_00 +000045D2_40D1748000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_41EFFFFFB7E00000_00 +00000189_4078900000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_41EFFFCDFFC00000_00 +008672A0_4160CE5400000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +0000CA70_40E94E0000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +000148E7_40F48E7000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_41EEFFBFFDC00000_00 +00000030_4048000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_41EFFFE03FA00000_00 +0010FAEF_4130FAEF00000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000001F5_407F500000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_41EFFC0FF8000000_00 +005AFFFB_4156BFFEC0000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +034613B2_418A309D90000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_41EE0000BFC00000_00 +000B6402_4126C80400000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_41EFFFFFA0400000_00 +000341C6_410A0E3000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +00000003_4008000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_41EFCFFBFFC00000_00 +0000003D_404E800000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_41EB77FFFFC00000_00 +00000C04_40A8080000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_41EFFFF803000000_00 +00006853_40DA14C000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +00000124_4072400000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_41EFFFFDF7C00000_00 +000B9AD8_412735B000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_41EBFFFFBFC00000_00 +00000595_4096540000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +00000010_4030000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +030EC496_41887624B0000000_00 +0000007F_405FC00000000000_00 +B8007FFF_41E7000FFFE00000_00 +00000112_4071200000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +0000002F_4047800000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_41EFEFFFE0400000_00 +000002CE_4086700000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +00000644_4099100000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +0000B8E7_40E71CE000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f64_ru.tv b/wally-pipelined/testbench/fp/ui32_f64_ru.tv new file mode 100644 index 000000000..ce22e2c74 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f64_ru.tv @@ -0,0 +1,372 @@ +1FEFFFEF_41BFEFFFEF000000_00 +0000448E_40D1238000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00019E14_40F9E14000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +0000DE38_40EBC70000000000_00 +00000002_4000000000000000_00 +FFDFFC02_41EFFBFF80400000_00 +03794C79_418BCA63C8000000_00 +00000004_4010000000000000_00 +F00FFFFE_41EE01FFFFC00000_00 +00010A95_40F0A95000000000_00 +00000008_4020000000000000_00 +FFFFF97F_41EFFFFF2FE00000_00 +01AE458D_417AE458D0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +69EB4561_41DA7AD158400000_00 +00000020_4040000000000000_00 +8001FFEE_41E0003FFDC00000_00 +0003DD08_410EE84000000000_00 +00000040_4050000000000000_00 +FFF03FF9_41EFFE07FF200000_00 +000EDF36_412DBE6C00000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000679_4099E40000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_41E7FFFFFDE00000_00 +0000000F_402E000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +00000590_4096400000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_41EEFFFFDF600000_00 +6FEA335F_41DBFA8CD7C00000_00 +00000800_40A0000000000000_00 +FFC07FFF_41EFF80FFFE00000_00 +377957FD_41CBBCABFE800000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +00000AC9_40A5920000000000_00 +00002000_40C0000000000000_00 +FFFF8004_41EFFFF000800000_00 +000BE0DE_4127C1BC00000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000400_4090000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_41EFF0403FE00000_00 +0001D2F1_40FD2F1000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0031B7E5_4148DBF280000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0213F7E6_41809FBF30000000_00 +00040000_4110000000000000_00 +FFFDC007_41EFFFB800E00000_00 +1D0ABD9A_41BD0ABD9A000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00007CEE_40DF3B8000000000_00 +00100000_4130000000000000_00 +DFDFE000_41EBFBFC00000000_00 +01FB1642_417FB16420000000_00 +00200000_4140000000000000_00 +FC000078_41EF80000F000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +00000221_4081080000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_41EFEF7FEFE00000_00 +00016393_40F6393000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +000005B4_4096D00000000000_00 +02000000_4180000000000000_00 +8002FFFF_41E0005FFFE00000_00 +000048E2_40D2388000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_41EFFF81BFC00000_00 +0000071B_409C6C0000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0003092B_4108495800000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +01B4F3D1_417B4F3D10000000_00 +20000000_41C0000000000000_00 +FEF801FF_41EFDF003FE00000_00 +0000000D_402A000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_41E7FE7FFFC00000_00 +0009806B_412300D600000000_00 +80000000_41E0000000000000_00 +0000A07E_40E40FC000000000_00 +0000A59F_40E4B3E000000000_00 +C0000000_41E8000000000000_00 +E0007FDE_41EC000FFBC00000_00 +0000343E_40CA1F0000000000_00 +E0000000_41EC000000000000_00 +0000FF7C_40EFEF8000000000_00 +00000007_401C000000000000_00 +F0000000_41EE000000000000_00 +BDFFFFFC_41E7BFFFFF800000_00 +0001E3C1_40FE3C1000000000_00 +F8000000_41EF000000000000_00 +28003FFE_41C4001FFF000000_00 +00000008_4020000000000000_00 +FC000000_41EF800000000000_00 +00EEFFFF_416DDFFFE0000000_00 +0000BEB0_40E7D60000000000_00 +FE000000_41EFC00000000000_00 +00000F7D_40AEFA0000000000_00 +0000000F_402E000000000000_00 +FF000000_41EFE00000000000_00 +0000406D_40D01B4000000000_00 +0000009A_4063400000000000_00 +FF800000_41EFF00000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000001A_403A000000000000_00 +FFC00000_41EFF80000000000_00 +FFFF007C_41EFFFE00F800000_00 +0000409B_40D026C000000000_00 +FFE00000_41EFFC0000000000_00 +00E00FFF_416C01FFE0000000_00 +0000000E_402C000000000000_00 +FFF00000_41EFFE0000000000_00 +00200FFC_414007FE00000000_00 +00001714_40B7140000000000_00 +FFF80000_41EFFF0000000000_00 +F800040E_41EF000081C00000_00 +00000113_4071300000000000_00 +FFFC0000_41EFFF8000000000_00 +F83BFFFF_41EF077FFFE00000_00 +0003F584_410FAC2000000000_00 +FFFE0000_41EFFFC000000000_00 +F6FFFBFF_41EEDFFF7FE00000_00 +00000000_0000000000000000_00 +FFFF0000_41EFFFE000000000_00 +80003FFD_41E00007FFA00000_00 +0000002D_4046800000000000_00 +FFFF8000_41EFFFF000000000_00 +004001FD_4150007F40000000_00 +001D734E_413D734E00000000_00 +FFFFC000_41EFFFF800000000_00 +006003FE_415800FF80000000_00 +019DBAA8_4179DBAA80000000_00 +FFFFE000_41EFFFFC00000000_00 +000403EE_41100FB800000000_00 +08734668_41A0E68CD0000000_00 +FFFFF000_41EFFFFE00000000_00 +01200002_4172000020000000_00 +000874A5_4120E94A00000000_00 +FFFFF800_41EFFFFF00000000_00 +00060001_4118000400000000_00 +00000008_4020000000000000_00 +FFFFFC00_41EFFFFF80000000_00 +001FFEDD_413FFEDD00000000_00 +000056DF_40D5B7C000000000_00 +FFFFFE00_41EFFFFFC0000000_00 +EFFFEFFD_41EDFFFDFFA00000_00 +02CF5EC6_41867AF630000000_00 +FFFFFF00_41EFFFFFE0000000_00 +1FF00002_41BFF00002000000_00 +06DB786B_419B6DE1AC000000_00 +FFFFFF80_41EFFFFFF0000000_00 +F0000FBE_41EE0001F7C00000_00 +00000019_4039000000000000_00 +FFFFFFC0_41EFFFFFF8000000_00 +0010801F_4130801F00000000_00 +0003F238_410F91C000000000_00 +FFFFFFE0_41EFFFFFFC000000_00 +F8000047_41EF000008E00000_00 +0006133C_41184CF000000000_00 +FFFFFFF0_41EFFFFFFE000000_00 +003C001F_414E000F80000000_00 +000009F1_40A3E20000000000_00 +FFFFFFF8_41EFFFFFFF000000_00 +FFDFBFFF_41EFFBF7FFE00000_00 +015E507F_4175E507F0000000_00 +FFFFFFFC_41EFFFFFFF800000_00 +037FFFDE_418BFFFEF0000000_00 +00017C6F_40F7C6F000000000_00 +FFFFFFFE_41EFFFFFFFC00000_00 +000000FD_406FA00000000000_00 +0000042A_4090A80000000000_00 +FFFFFFFF_41EFFFFFFFE00000_00 +021FFF7D_4180FFFBE8000000_00 +0000002A_4045000000000000_00 +FFFFFFFD_41EFFFFFFFA00000_00 +4010FFFF_41D0043FFFC00000_00 +00000013_4033000000000000_00 +FFFFFFFB_41EFFFFFFF600000_00 +FFFF800B_41EFFFF001600000_00 +000004B8_4092E00000000000_00 +FFFFFFF7_41EFFFFFFEE00000_00 +FF800803_41EFF00100600000_00 +00000006_4018000000000000_00 +FFFFFFEF_41EFFFFFFDE00000_00 +00803FFB_416007FF60000000_00 +00000708_409C200000000000_00 +FFFFFFDF_41EFFFFFFBE00000_00 +2107FFFE_41C083FFFF000000_00 +00215D4F_4140AEA780000000_00 +FFFFFFBF_41EFFFFFF7E00000_00 +400087FD_41D00021FF400000_00 +0000001F_403F000000000000_00 +FFFFFF7F_41EFFFFFEFE00000_00 +FDFC007E_41EFBF800FC00000_00 +0000000E_402C000000000000_00 +FFFFFEFF_41EFFFFFDFE00000_00 +FFF80100_41EFFF0020000000_00 +00000699_409A640000000000_00 +FFFFFDFF_41EFFFFFBFE00000_00 +03000002_4188000010000000_00 +000716EA_411C5BA800000000_00 +FFFFFBFF_41EFFFFF7FE00000_00 +C7FDFFFF_41E8FFBFFFE00000_00 +00000327_4089380000000000_00 +FFFFF7FF_41EFFFFEFFE00000_00 +0103DFFE_41703DFFE0000000_00 +47661FD8_41D1D987F6000000_00 +FFFFEFFF_41EFFFFDFFE00000_00 +83FFFFFE_41E07FFFFFC00000_00 +0CD956DB_41A9B2ADB6000000_00 +FFFFDFFF_41EFFFFBFFE00000_00 +FF2001FD_41EFE4003FA00000_00 +04D35BBF_41934D6EFC000000_00 +FFFFBFFF_41EFFFF7FFE00000_00 +DFEFEFFE_41EBFDFDFFC00000_00 +15DA4300_41B5DA4300000000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +40001040_41D0000410000000_00 +812EDF40_41E025DBE8000000_00 +FFFEFFFF_41EFFFDFFFE00000_00 +FFFFC007_41EFFFF800E00000_00 +08B6FCC9_41A16DF992000000_00 +FFFDFFFF_41EFFFBFFFE00000_00 +000007FE_409FF80000000000_00 +003DE950_414EF4A800000000_00 +FFFBFFFF_41EFFF7FFFE00000_00 +7FFFFE03_41DFFFFF80C00000_00 +02B02B59_4185815AC8000000_00 +FFF7FFFF_41EFFEFFFFE00000_00 +10FF7FFF_41B0FF7FFF000000_00 +00408D5E_4150235780000000_00 +FFEFFFFF_41EFFDFFFFE00000_00 +FFFF007E_41EFFFE00FC00000_00 +003C2108_414E108400000000_00 +FFDFFFFF_41EFFBFFFFE00000_00 +00FFC001_416FF80020000000_00 +001C6B36_413C6B3600000000_00 +FFBFFFFF_41EFF7FFFFE00000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +0001D055_40FD055000000000_00 +FF7FFFFF_41EFEFFFFFE00000_00 +027BFFFE_4183DFFFF0000000_00 +013090D0_4173090D00000000_00 +FEFFFFFF_41EFDFFFFFE00000_00 +00082040_4120408000000000_00 +000000EE_406DC00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +FDFFFF87_41EFBFFFF0E00000_00 +14C3764D_41B4C3764D000000_00 +FBFFFFFF_41EF7FFFFFE00000_00 +0006007E_411801F800000000_00 +000003EF_408F780000000000_00 +F7FFFFFF_41EEFFFFFFE00000_00 +FFBF7FFE_41EFF7EFFFC00000_00 +001C4E5A_413C4E5A00000000_00 +EFFFFFFF_41EDFFFFFFE00000_00 +FFF97FFD_41EFFF2FFFA00000_00 +000005D1_4097440000000000_00 +DFFFFFFF_41EBFFFFFFE00000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00936721_41626CE420000000_00 +BFFFFFFF_41E7FFFFFFE00000_00 +00004BFF_40D2FFC000000000_00 +00002544_40C2A20000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +0000BD5E_40E7ABC000000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_41EFF7F000600000_00 +000045D2_40D1748000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_41EFFFFFB7E00000_00 +00000189_4078900000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_41EFFFCDFFC00000_00 +008672A0_4160CE5400000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +0000CA70_40E94E0000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +000148E7_40F48E7000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_41EEFFBFFDC00000_00 +00000030_4048000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_41EFFFE03FA00000_00 +0010FAEF_4130FAEF00000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000001F5_407F500000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_41EFFC0FF8000000_00 +005AFFFB_4156BFFEC0000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +034613B2_418A309D90000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_41EE0000BFC00000_00 +000B6402_4126C80400000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_41EFFFFFA0400000_00 +000341C6_410A0E3000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +00000003_4008000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_41EFCFFBFFC00000_00 +0000003D_404E800000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_41EB77FFFFC00000_00 +00000C04_40A8080000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_41EFFFF803000000_00 +00006853_40DA14C000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +00000124_4072400000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_41EFFFFDF7C00000_00 +000B9AD8_412735B000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_41EBFFFFBFC00000_00 +00000595_4096540000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +00000010_4030000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +030EC496_41887624B0000000_00 +0000007F_405FC00000000000_00 +B8007FFF_41E7000FFFE00000_00 +00000112_4071200000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +0000002F_4047800000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_41EFEFFFE0400000_00 +000002CE_4086700000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +00000644_4099100000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +0000B8E7_40E71CE000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui32_f64_rz.tv b/wally-pipelined/testbench/fp/ui32_f64_rz.tv new file mode 100644 index 000000000..ce22e2c74 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui32_f64_rz.tv @@ -0,0 +1,372 @@ +1FEFFFEF_41BFEFFFEF000000_00 +0000448E_40D1238000000000_00 +00000000_0000000000000000_00 +007FFFCD_415FFFF340000000_00 +00019E14_40F9E14000000000_00 +00000001_3FF0000000000000_00 +001FFFFB_413FFFFB00000000_00 +0000DE38_40EBC70000000000_00 +00000002_4000000000000000_00 +FFDFFC02_41EFFBFF80400000_00 +03794C79_418BCA63C8000000_00 +00000004_4010000000000000_00 +F00FFFFE_41EE01FFFFC00000_00 +00010A95_40F0A95000000000_00 +00000008_4020000000000000_00 +FFFFF97F_41EFFFFF2FE00000_00 +01AE458D_417AE458D0000000_00 +00000010_4030000000000000_00 +0101001E_41701001E0000000_00 +69EB4561_41DA7AD158400000_00 +00000020_4040000000000000_00 +8001FFEE_41E0003FFDC00000_00 +0003DD08_410EE84000000000_00 +00000040_4050000000000000_00 +FFF03FF9_41EFFE07FF200000_00 +000EDF36_412DBE6C00000000_00 +00000080_4060000000000000_00 +0000F01F_40EE03E000000000_00 +00000679_4099E40000000000_00 +00000100_4070000000000000_00 +BFFFFFEF_41E7FFFFFDE00000_00 +0000000F_402E000000000000_00 +00000200_4080000000000000_00 +010BFFFD_4170BFFFD0000000_00 +00000590_4096400000000000_00 +00000400_4090000000000000_00 +F7FFFEFB_41EEFFFFDF600000_00 +6FEA335F_41DBFA8CD7C00000_00 +00000800_40A0000000000000_00 +FFC07FFF_41EFF80FFFE00000_00 +377957FD_41CBBCABFE800000_00 +00001000_40B0000000000000_00 +01FBFFEE_417FBFFEE0000000_00 +00000AC9_40A5920000000000_00 +00002000_40C0000000000000_00 +FFFF8004_41EFFFF000800000_00 +000BE0DE_4127C1BC00000000_00 +00004000_40D0000000000000_00 +3F00001E_41CF80000F000000_00 +00000400_4090000000000000_00 +00008000_40E0000000000000_00 +FF8201FF_41EFF0403FE00000_00 +0001D2F1_40FD2F1000000000_00 +00010000_40F0000000000000_00 +0000047E_4091F80000000000_00 +0031B7E5_4148DBF280000000_00 +00020000_4100000000000000_00 +02200200_4181001000000000_00 +0213F7E6_41809FBF30000000_00 +00040000_4110000000000000_00 +FFFDC007_41EFFFB800E00000_00 +1D0ABD9A_41BD0ABD9A000000_00 +00080000_4120000000000000_00 +0000607F_40D81FC000000000_00 +00007CEE_40DF3B8000000000_00 +00100000_4130000000000000_00 +DFDFE000_41EBFBFC00000000_00 +01FB1642_417FB16420000000_00 +00200000_4140000000000000_00 +FC000078_41EF80000F000000_00 +5F70EEC1_41D7DC3BB0400000_00 +00400000_4150000000000000_00 +00100082_4130008200000000_00 +00000221_4081080000000000_00 +00800000_4160000000000000_00 +FF7BFF7F_41EFEF7FEFE00000_00 +00016393_40F6393000000000_00 +01000000_4170000000000000_00 +07EFFEFD_419FBFFBF4000000_00 +000005B4_4096D00000000000_00 +02000000_4180000000000000_00 +8002FFFF_41E0005FFFE00000_00 +000048E2_40D2388000000000_00 +04000000_4190000000000000_00 +FFFC0DFE_41EFFF81BFC00000_00 +0000071B_409C6C0000000000_00 +08000000_41A0000000000000_00 +03FFFDBF_418FFFEDF8000000_00 +0003092B_4108495800000000_00 +10000000_41B0000000000000_00 +007FBFFD_415FEFFF40000000_00 +01B4F3D1_417B4F3D10000000_00 +20000000_41C0000000000000_00 +FEF801FF_41EFDF003FE00000_00 +0000000D_402A000000000000_00 +40000000_41D0000000000000_00 +BFF3FFFE_41E7FE7FFFC00000_00 +0009806B_412300D600000000_00 +80000000_41E0000000000000_00 +0000A07E_40E40FC000000000_00 +0000A59F_40E4B3E000000000_00 +C0000000_41E8000000000000_00 +E0007FDE_41EC000FFBC00000_00 +0000343E_40CA1F0000000000_00 +E0000000_41EC000000000000_00 +0000FF7C_40EFEF8000000000_00 +00000007_401C000000000000_00 +F0000000_41EE000000000000_00 +BDFFFFFC_41E7BFFFFF800000_00 +0001E3C1_40FE3C1000000000_00 +F8000000_41EF000000000000_00 +28003FFE_41C4001FFF000000_00 +00000008_4020000000000000_00 +FC000000_41EF800000000000_00 +00EEFFFF_416DDFFFE0000000_00 +0000BEB0_40E7D60000000000_00 +FE000000_41EFC00000000000_00 +00000F7D_40AEFA0000000000_00 +0000000F_402E000000000000_00 +FF000000_41EFE00000000000_00 +0000406D_40D01B4000000000_00 +0000009A_4063400000000000_00 +FF800000_41EFF00000000000_00 +203FFFFD_41C01FFFFE800000_00 +0000001A_403A000000000000_00 +FFC00000_41EFF80000000000_00 +FFFF007C_41EFFFE00F800000_00 +0000409B_40D026C000000000_00 +FFE00000_41EFFC0000000000_00 +00E00FFF_416C01FFE0000000_00 +0000000E_402C000000000000_00 +FFF00000_41EFFE0000000000_00 +00200FFC_414007FE00000000_00 +00001714_40B7140000000000_00 +FFF80000_41EFFF0000000000_00 +F800040E_41EF000081C00000_00 +00000113_4071300000000000_00 +FFFC0000_41EFFF8000000000_00 +F83BFFFF_41EF077FFFE00000_00 +0003F584_410FAC2000000000_00 +FFFE0000_41EFFFC000000000_00 +F6FFFBFF_41EEDFFF7FE00000_00 +00000000_0000000000000000_00 +FFFF0000_41EFFFE000000000_00 +80003FFD_41E00007FFA00000_00 +0000002D_4046800000000000_00 +FFFF8000_41EFFFF000000000_00 +004001FD_4150007F40000000_00 +001D734E_413D734E00000000_00 +FFFFC000_41EFFFF800000000_00 +006003FE_415800FF80000000_00 +019DBAA8_4179DBAA80000000_00 +FFFFE000_41EFFFFC00000000_00 +000403EE_41100FB800000000_00 +08734668_41A0E68CD0000000_00 +FFFFF000_41EFFFFE00000000_00 +01200002_4172000020000000_00 +000874A5_4120E94A00000000_00 +FFFFF800_41EFFFFF00000000_00 +00060001_4118000400000000_00 +00000008_4020000000000000_00 +FFFFFC00_41EFFFFF80000000_00 +001FFEDD_413FFEDD00000000_00 +000056DF_40D5B7C000000000_00 +FFFFFE00_41EFFFFFC0000000_00 +EFFFEFFD_41EDFFFDFFA00000_00 +02CF5EC6_41867AF630000000_00 +FFFFFF00_41EFFFFFE0000000_00 +1FF00002_41BFF00002000000_00 +06DB786B_419B6DE1AC000000_00 +FFFFFF80_41EFFFFFF0000000_00 +F0000FBE_41EE0001F7C00000_00 +00000019_4039000000000000_00 +FFFFFFC0_41EFFFFFF8000000_00 +0010801F_4130801F00000000_00 +0003F238_410F91C000000000_00 +FFFFFFE0_41EFFFFFFC000000_00 +F8000047_41EF000008E00000_00 +0006133C_41184CF000000000_00 +FFFFFFF0_41EFFFFFFE000000_00 +003C001F_414E000F80000000_00 +000009F1_40A3E20000000000_00 +FFFFFFF8_41EFFFFFFF000000_00 +FFDFBFFF_41EFFBF7FFE00000_00 +015E507F_4175E507F0000000_00 +FFFFFFFC_41EFFFFFFF800000_00 +037FFFDE_418BFFFEF0000000_00 +00017C6F_40F7C6F000000000_00 +FFFFFFFE_41EFFFFFFFC00000_00 +000000FD_406FA00000000000_00 +0000042A_4090A80000000000_00 +FFFFFFFF_41EFFFFFFFE00000_00 +021FFF7D_4180FFFBE8000000_00 +0000002A_4045000000000000_00 +FFFFFFFD_41EFFFFFFFA00000_00 +4010FFFF_41D0043FFFC00000_00 +00000013_4033000000000000_00 +FFFFFFFB_41EFFFFFFF600000_00 +FFFF800B_41EFFFF001600000_00 +000004B8_4092E00000000000_00 +FFFFFFF7_41EFFFFFFEE00000_00 +FF800803_41EFF00100600000_00 +00000006_4018000000000000_00 +FFFFFFEF_41EFFFFFFDE00000_00 +00803FFB_416007FF60000000_00 +00000708_409C200000000000_00 +FFFFFFDF_41EFFFFFFBE00000_00 +2107FFFE_41C083FFFF000000_00 +00215D4F_4140AEA780000000_00 +FFFFFFBF_41EFFFFFF7E00000_00 +400087FD_41D00021FF400000_00 +0000001F_403F000000000000_00 +FFFFFF7F_41EFFFFFEFE00000_00 +FDFC007E_41EFBF800FC00000_00 +0000000E_402C000000000000_00 +FFFFFEFF_41EFFFFFDFE00000_00 +FFF80100_41EFFF0020000000_00 +00000699_409A640000000000_00 +FFFFFDFF_41EFFFFFBFE00000_00 +03000002_4188000010000000_00 +000716EA_411C5BA800000000_00 +FFFFFBFF_41EFFFFF7FE00000_00 +C7FDFFFF_41E8FFBFFFE00000_00 +00000327_4089380000000000_00 +FFFFF7FF_41EFFFFEFFE00000_00 +0103DFFE_41703DFFE0000000_00 +47661FD8_41D1D987F6000000_00 +FFFFEFFF_41EFFFFDFFE00000_00 +83FFFFFE_41E07FFFFFC00000_00 +0CD956DB_41A9B2ADB6000000_00 +FFFFDFFF_41EFFFFBFFE00000_00 +FF2001FD_41EFE4003FA00000_00 +04D35BBF_41934D6EFC000000_00 +FFFFBFFF_41EFFFF7FFE00000_00 +DFEFEFFE_41EBFDFDFFC00000_00 +15DA4300_41B5DA4300000000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +40001040_41D0000410000000_00 +812EDF40_41E025DBE8000000_00 +FFFEFFFF_41EFFFDFFFE00000_00 +FFFFC007_41EFFFF800E00000_00 +08B6FCC9_41A16DF992000000_00 +FFFDFFFF_41EFFFBFFFE00000_00 +000007FE_409FF80000000000_00 +003DE950_414EF4A800000000_00 +FFFBFFFF_41EFFF7FFFE00000_00 +7FFFFE03_41DFFFFF80C00000_00 +02B02B59_4185815AC8000000_00 +FFF7FFFF_41EFFEFFFFE00000_00 +10FF7FFF_41B0FF7FFF000000_00 +00408D5E_4150235780000000_00 +FFEFFFFF_41EFFDFFFFE00000_00 +FFFF007E_41EFFFE00FC00000_00 +003C2108_414E108400000000_00 +FFDFFFFF_41EFFBFFFFE00000_00 +00FFC001_416FF80020000000_00 +001C6B36_413C6B3600000000_00 +FFBFFFFF_41EFF7FFFFE00000_00 +FFFF7FFF_41EFFFEFFFE00000_00 +0001D055_40FD055000000000_00 +FF7FFFFF_41EFEFFFFFE00000_00 +027BFFFE_4183DFFFF0000000_00 +013090D0_4173090D00000000_00 +FEFFFFFF_41EFDFFFFFE00000_00 +00082040_4120408000000000_00 +000000EE_406DC00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +FDFFFF87_41EFBFFFF0E00000_00 +14C3764D_41B4C3764D000000_00 +FBFFFFFF_41EF7FFFFFE00000_00 +0006007E_411801F800000000_00 +000003EF_408F780000000000_00 +F7FFFFFF_41EEFFFFFFE00000_00 +FFBF7FFE_41EFF7EFFFC00000_00 +001C4E5A_413C4E5A00000000_00 +EFFFFFFF_41EDFFFFFFE00000_00 +FFF97FFD_41EFFF2FFFA00000_00 +000005D1_4097440000000000_00 +DFFFFFFF_41EBFFFFFFE00000_00 +2FFFFFFE_41C7FFFFFF000000_00 +00936721_41626CE420000000_00 +BFFFFFFF_41E7FFFFFFE00000_00 +00004BFF_40D2FFC000000000_00 +00002544_40C2A20000000000_00 +7FFFFFFF_41DFFFFFFFC00000_00 +007FDFFB_415FF7FEC0000000_00 +0000BD5E_40E7ABC000000000_00 +3FFFFFFF_41CFFFFFFF800000_00 +FFBF8003_41EFF7F000600000_00 +000045D2_40D1748000000000_00 +1FFFFFFF_41BFFFFFFF000000_00 +FFFFFDBF_41EFFFFFB7E00000_00 +00000189_4078900000000000_00 +0FFFFFFF_41AFFFFFFE000000_00 +FFFE6FFE_41EFFFCDFFC00000_00 +008672A0_4160CE5400000000_00 +07FFFFFF_419FFFFFFC000000_00 +00000107_4070700000000000_00 +0000CA70_40E94E0000000000_00 +03FFFFFF_418FFFFFF8000000_00 +002107FE_414083FF00000000_00 +000148E7_40F48E7000000000_00 +01FFFFFF_417FFFFFF0000000_00 +F7FDFFEE_41EEFFBFFDC00000_00 +00000030_4048000000000000_00 +00FFFFFF_416FFFFFE0000000_00 +FFFF01FD_41EFFFE03FA00000_00 +0010FAEF_4130FAEF00000000_00 +007FFFFF_415FFFFFC0000000_00 +00FC0001_416F800020000000_00 +000001F5_407F500000000000_00 +003FFFFF_414FFFFF80000000_00 +FFE07FC0_41EFFC0FF8000000_00 +005AFFFB_4156BFFEC0000000_00 +001FFFFF_413FFFFF00000000_00 +00101FFD_41301FFD00000000_00 +034613B2_418A309D90000000_00 +000FFFFF_412FFFFE00000000_00 +F00005FE_41EE0000BFC00000_00 +000B6402_4126C80400000000_00 +0007FFFF_411FFFFC00000000_00 +0404FFFF_419013FFFC000000_00 +021C2358_4180E11AC0000000_00 +0003FFFF_410FFFF800000000_00 +FFFFFD02_41EFFFFFA0400000_00 +000341C6_410A0E3000000000_00 +0001FFFF_40FFFFF000000000_00 +00000007_401C000000000000_00 +27F174DE_41C3F8BA6F000000_00 +0000FFFF_40EFFFE000000000_00 +000083F5_40E07EA000000000_00 +00000003_4008000000000000_00 +00007FFF_40DFFFC000000000_00 +FE7FDFFE_41EFCFFBFFC00000_00 +0000003D_404E800000000000_00 +00003FFF_40CFFF8000000000_00 +DBBFFFFE_41EB77FFFFC00000_00 +00000C04_40A8080000000000_00 +00001FFF_40BFFF0000000000_00 +FFFFC018_41EFFFF803000000_00 +00006853_40DA14C000000000_00 +00000FFF_40AFFE0000000000_00 +03FE007F_418FF003F8000000_00 +00000124_4072400000000000_00 +000007FF_409FFC0000000000_00 +FFFFEFBE_41EFFFFDF7C00000_00 +000B9AD8_412735B000000000_00 +000003FF_408FF80000000000_00 +DFFFFDFE_41EBFFFFBFC00000_00 +00000595_4096540000000000_00 +000001FF_407FF00000000000_00 +FDFFFFFF_41EFBFFFFFE00000_00 +00000010_4030000000000000_00 +000000FF_406FE00000000000_00 +0037FFE0_414BFFF000000000_00 +030EC496_41887624B0000000_00 +0000007F_405FC00000000000_00 +B8007FFF_41E7000FFFE00000_00 +00000112_4071200000000000_00 +0000003F_404F800000000000_00 +02003FFC_418001FFE0000000_00 +0000002F_4047800000000000_00 +0000001F_403F000000000000_00 +FF7FFF02_41EFEFFFE0400000_00 +000002CE_4086700000000000_00 +0000000F_402E000000000000_00 +0000A00D_40E401A000000000_00 +00000644_4099100000000000_00 +00000007_401C000000000000_00 +0003FFFA_410FFFD000000000_00 +0000B8E7_40E71CE000000000_00 +00000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f32_rd.tv b/wally-pipelined/testbench/fp/ui64_f32_rd.tv new file mode 100644 index 000000000..bf85027ae --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f32_rd.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_5CFFFFBF_01 +0000000072CC8B7A_4EE59916_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_5F7FFFFF_01 +072C857F319EDE38_5CE590AF_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_5F7FFFFB_01 +00794C79B6D3007B_5AF298F3_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_5F7BFFFF_01 +0000000005AE458D_4CB5C8B1_01 +0000000000000004_40800000_00 +00040008000007FE_58800100_01 +09EB456140D88764_5D1EB456_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_5F7FFFE4_01 +27DE834A248EDF36_5E1F7A0D_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC007_01 +00000000000385E2_48617880_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_5F70041F_01 +000000159EB1FD45_51ACF58F_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_5F7FFFFF_01 +000000000002DDFE_48377F80_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000002C89FF56B_503227FD_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF7_01 +3B5E4F0BE0DEBFF0_5E6D793C_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_5F7FFDF8_01 +000000000004766B_488ECD60_00 +0000000000000400_44800000_00 +0000080100000FFE_55001000_01 +000000000000002C_42300000_00 +0000000000000800_45000000_00 +0048000000100000_5A900000_01 +07E662A109109D0A_5CFCCC54_01 +0000000000001000_45800000_00 +C000000037FFFFFE_5F400000_01 +0000000000000064_42C80000_00 +0000000000002000_46000000_00 +F801000000100000_5F780100_01 +02114B79075F70EE_5C0452DE_01 +0000000000004000_46800000_00 +100000000001003E_5D800000_01 +0000000000000BAC_453AC000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000003_01 +000000C4A3A3DBE5_5344A3A3_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_5F7FE000_01 +0000000000001A91_45D48800_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_5F7FFFF7_01 +0000000000007309_46E61200_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF7_01 +0000000000000F58_45758000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_5F7FFFFF_01 +0000000000006980_46D30000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF07F_01 +00000000000000DD_435D0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF7F_01 +00008C23DA2CEAD8_570C23DA_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_5F600000_01 +00000DE3C1DEC43C_555E3C1D_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_5F7FFF00_01 +000000008030FFBE_4F0030FF_01 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_5F7FFE00_01 +000000000FDEED86_4D7DEED8_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_5F73FFFF_01 +000000005DA3FF45_4EBB47FE_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_5F7FFFFF_01 +000000009B1BCB54_4F1B1BCB_01 +0000000008000000_4D000000_00 +00004000004001FE_56800000_01 +027DD19DE6563714_5C1F7467_01 +0000000010000000_4D800000_00 +FFC00000004007FE_5F7FC000_01 +000000000003A359_4868D640_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C70003F_01 +000000003E62EC20_4E798BB0_01 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E7FFFFF_01 +000000000000685F_46D0BE00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_5F7FFFFF_01 +00000836F99DBAA8_55036F99_01 +0000000100000000_4F800000_00 +00000020003FFEFE_520000FF_01 +0073466832042D47_5AE68CD0_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_5F7FFFFF_01 +00000000007829C8_4AF05390_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_557FFFFF_01 +0000001FB77C672B_51FDBBE3_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D0003FF_01 +0000000000005B78_46B6F000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_5F7F7FFF_01 +00000000000000F1_43710000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_559FFFFF_01 +0000000000000006_40C00000_00 +0000004000000000_52800000_00 +0800000000040800_5D000000_01 +0008A60D9E19F17E_590A60D9_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +0000000007506DBA_4CEA0DB7_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_5F7FFFFF_01 +0000000006A42AC9_4CD48559_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_5583FFFF_01 +0007AA3F2BDACC89_58F547E5_01 +0000040000000000_54800000_00 +FFF8040000040000_5F7FF804_01 +0000000000000005_40A00000_00 +0000080000000000_55000000_00 +FFFF80000800001F_5F7FFF80_01 +000DF681DECDADC9_595F681D_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_5F7FFFFE_01 +0000000000004FBE_469F7C00_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51101FFF_01 +00C01FECA24DE1B0_5B401FEC_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_5F77FFFF_01 +0058A66761669936_5AB14CCE_01 +0000800000000000_57000000_00 +FFFEFF800000003E_5F7FFEFF_01 +0716EA43FAC45C97_5CE2DD48_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_5F7FFFFF_01 +0064D70EC7661FD8_5AC9AE1D_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_5F407FFF_01 +00D956DBD0AEE817_5B5956DB_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FB_01 +0000000000004300_46860000_00 +0008000000000000_59000000_00 +4000000004002000_5E800000_01 +012EDF40F41F6021_5B976FA0_01 +0010000000000000_59800000_00 +FF9000000000001D_5F7F9000_01 +000000383DE950F6_5260F7A5_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_5F000003_01 +002B59CB3A604D69_5A2D672C_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5EFFFFFF_01 +000001A37C210862_53D1BE10_01 +0080000000000000_5B000000_00 +0002000002000002_58000000_01 +0000365CD8617789_56597361_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55DFFFFF_01 +000000000000101D_4580E800_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800004_01 +000000001D098D19_4DE84C68_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C7FFFFF_01 +000016B3BD2C7BEF_55B59DE9_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFEFF_01 +00004E5ADDDAA4A8_569CB5BB_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE00_01 +0000000000000721_44E42000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83BFFF_01 +0000000000648262_4AC904C4_00 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_5F40001F_01 +0000007353AC45D2_52E6A758_01 +8000000000000000_5F000000_00 +FFFFFFFFFFE7EFFF_5F7FFFFF_01 +0000000001A1202D_4BD09016_01 +C000000000000000_5F400000_00 +FFFFFFFFFFFF5F7F_5F7FFFFF_01 +0000000000C0CA70_4B40CA70_00 +E000000000000000_5F600000_00 +0000200201FFFFFE_56000807_01 +00000007B55D87D4_50F6ABB0_01 +F000000000000000_5F700000_00 +FF80000DFFFFFFFF_5F7F8000_01 +000000090510FAEF_5110510F_01 +F800000000000000_5F780000_00 +0003FFF00000000F_587FFC00_01 +000000000001724A_47B92500_00 +FC00000000000000_5F7C0000_00 +FFFFFFDF80000002_5F7FFFFF_01 +00000000000000E4_43640000_00 +FE00000000000000_5F7E0000_00 +FEFFFFFFFFF800FE_5F7EFFFF_01 +00000002C6222702_50318889_01 +FF00000000000000_5F7F0000_00 +0000000408000002_50810000_01 +000002E96DF1CB41_543A5B7C_01 +FF80000000000000_5F7F8000_00 +007FFFFFFFFFF9FE_5AFFFFFF_01 +0727F174DEE7DC85_5CE4FE2E_01 +FFC0000000000000_5F7FC000_00 +8000000003FFFEFE_5F000000_01 +000000000010BD5B_4985EAD8_00 +FFE0000000000000_5F7FE000_00 +0BEFFFFFFFFFFFFF_5D3EFFFF_01 +000000000022790C_4A09E430_00 +FFF0000000000000_5F7FF000_00 +FFFFFFFFFFEFFBFA_5F7FFFFF_01 +000000369E75DF01_525A79D7_01 +FFF8000000000000_5F7FF800_00 +00000007FEFFDFFF_50FFDFFB_01 +000000000000001E_41F00000_00 +FFFC000000000000_5F7FFC00_00 +0003FFFE0007FFFE_587FFF80_01 +0000000000328622_4A4A1888_00 +FFFE000000000000_5F7FFE00_00 +FFFFFF7FFFFDF7FF_5F7FFFFF_01 +00172F0EC496FE21_59B97876_01 +FFFF000000000000_5F7FFF00_00 +DFBFFFFFFFFFFFFE_5F5FBFFF_01 +0000000004FC1FCA_4C9F83F9_01 +FFFF800000000000_5F7FFF80_00 +00000FFF800FFFFE_557FF800_01 +000F5194E4A9C2CE_5975194E_01 +FFFFC00000000000_5F7FFFC0_00 +00000002100007FD_50040001_01 +000000000002D8FE_48363F80_00 +FFFFE00000000000_5F7FFFE0_00 +000000000007FF6E_48FFEDC0_00 +000000000003766E_485D9B80_00 +FFFFF00000000000_5F7FFFF0_00 +0040000400000002_5A800008_01 +000000000000F841_47784100_00 +FFFFF80000000000_5F7FFFF8_00 +3DFFFFFFFFFFFF7E_5E77FFFF_01 +0000000549E17E30_50A93C2F_01 +FFFFFC0000000000_5F7FFFFC_00 +FFFFFFFFFFFFFEE1_5F7FFFFF_01 +0000000000000027_421C0000_00 +FFFFFE0000000000_5F7FFFFE_00 +000000000EFFFFDF_4D6FFFFD_01 +0000000000000373_445CC000_00 +FFFFFF0000000000_5F7FFFFF_00 +FD00000008000000_5F7D0000_01 +000000000005DBB1_48BB7620_00 +FFFFFF8000000000_5F7FFFFF_01 +FFFFFFFFFFF8007F_5F7FFFFF_01 +00000002FD10A515_503F4429_01 +FFFFFFC000000000_5F7FFFFF_01 +FFEFFFFFFFFFFFFE_5F7FEFFF_01 +0AB02984F6283B6C_5D2B0298_01 +FFFFFFE000000000_5F7FFFFF_01 +FFFFFFBC000001FE_5F7FFFFF_01 +00B087C6B9FE7FE0_5B3087C6_01 +FFFFFFF000000000_5F7FFFFF_01 +FFF80001000007FE_5F7FF800_01 +01F2762EA6837956_5BF93B17_01 +FFFFFFF800000000_5F7FFFFF_01 +FFF7E0FFFFFFFFFE_5F7FF7E0_01 +00022E1175484626_580B845D_01 +FFFFFFFC00000000_5F7FFFFF_01 +0000200020000FFE_56000080_01 +000000000000168F_45B47800_00 +FFFFFFFE00000000_5F7FFFFF_01 +021FFFFFFFFBFFFF_5C07FFFF_01 +0000000000000001_3F800000_00 +FFFFFFFF00000000_5F7FFFFF_01 +FFFFFFD0000FFFFD_5F7FFFFF_01 +000001BDF6658B83_53DEFB32_01 +FFFFFFFF80000000_5F7FFFFF_01 +1000001FFDFFFFFF_5D800000_01 +000000000000BB5B_473B5B00_00 +FFFFFFFFC0000000_5F7FFFFF_01 +FFFFFFBFFE0FFFFF_5F7FFFFF_01 +0000000000000000_00000000_00 +FFFFFFFFE0000000_5F7FFFFF_01 +FFFFFFFBF00007FF_5F7FFFFF_01 +01E986274F48EAAD_5BF4C313_01 +FFFFFFFFF0000000_5F7FFFFF_01 +1FFFFFFDFFFFFF7F_5DFFFFFF_01 +000000000000CB5A_474B5A00_00 +FFFFFFFFF8000000_5F7FFFFF_01 +7FF000000000FFFF_5EFFE000_01 +0000000BC2717FC3_513C2717_01 +FFFFFFFFFC000000_5F7FFFFF_01 +FFFFFFE00008001F_5F7FFFFF_01 +00000000000FABDA_497ABDA0_00 +FFFFFFFFFE000000_5F7FFFFF_01 +0200000000000002_5C000000_01 +0000000000FDA53F_4B7DA53F_00 +FFFFFFFFFF000000_5F7FFFFF_01 +F6000003FFFFFFFE_5F760000_01 +0000000000000010_41800000_00 +FFFFFFFFFF800000_5F7FFFFF_01 +FFFFFFFFFFBFFF7E_5F7FFFFF_01 +00000001EE0FEA62_4FF707F5_01 +FFFFFFFFFFC00000_5F7FFFFF_01 +0000007FFF9FFFFD_52FFFF3F_01 +00000077F35EDC1D_52EFE6BD_01 +FFFFFFFFFFE00000_5F7FFFFF_01 +FFFFFFF7FDFFFF7D_5F7FFFFF_01 +00000000000003AD_446B4000_00 +FFFFFFFFFFF00000_5F7FFFFF_01 +FFFFFF0000100020_5F7FFFFF_01 +67F167FBC7FC5F9A_5ECFE2CF_01 +FFFFFFFFFFF80000_5F7FFFFF_01 +003FFFFFFFFC0001_5A7FFFFF_01 +002E48F9F4EBD30E_5A3923E7_01 +FFFFFFFFFFFC0000_5F7FFFFF_01 +DFFFFFFFFFFBFFFE_5F5FFFFF_01 +0091C23EE8C9424F_5B11C23E_01 +FFFFFFFFFFFE0000_5F7FFFFF_01 +F7DFFBFFFFFFFFFE_5F77DFFB_01 +00000000ACAE080C_4F2CAE08_01 +FFFFFFFFFFFF0000_5F7FFFFF_01 +FFFFC00010000020_5F7FFFC0_01 +0CD921F917B20E40_5D4D921F_01 +FFFFFFFFFFFF8000_5F7FFFFF_01 +F8000FFFFFFFFFFD_5F78000F_01 +00017C566BC7D811_57BE2B35_01 +FFFFFFFFFFFFC000_5F7FFFFF_01 +00000000000000FE_437E0000_00 +00F82AC14930D386_5B782AC1_01 +FFFFFFFFFFFFE000_5F7FFFFF_01 +00000000000003FC_447F0000_00 +008E62EC60E119FC_5B0E62EC_01 +FFFFFFFFFFFFF000_5F7FFFFF_01 +FFFFEFF7FF7FFFFE_5F7FFFEF_01 +1E2B1ECF210EEDC5_5DF158F6_01 +FFFFFFFFFFFFF800_5F7FFFFF_01 +00000000007FFF1F_4AFFFE3E_00 +000006534F5676F7_54CA69EA_01 +FFFFFFFFFFFFFC00_5F7FFFFF_01 +0000001004FFFFFD_518027FF_01 +0000435C939669F1_5686B927_01 +FFFFFFFFFFFFFE00_5F7FFFFF_01 +1FFFFFFFFFFFFDFD_5DFFFFFF_01 +0000000000000011_41880000_00 +FFFFFFFFFFFFFF00_5F7FFFFF_01 +01FFFFFFFBFFEFFE_5BFFFFFF_01 +000000000000036E_445B8000_00 +FFFFFFFFFFFFFF80_5F7FFFFF_01 +FFF7FFFFFFFFF7FD_5F7FF7FF_01 +000038E2BCFAC553_56638AF3_01 +FFFFFFFFFFFFFFC0_5F7FFFFF_01 +FFFFFBFFFFFE0FFE_5F7FFFFB_01 +00000009A4E704BF_511A4E70_01 +FFFFFFFFFFFFFFE0_5F7FFFFF_01 +1400007FFFFFFFFD_5DA00003_01 +0000000093B187B4_4F13B187_01 +FFFFFFFFFFFFFFF0_5F7FFFFF_01 +40000000007FFFFD_5E800000_01 +0000000000E7D468_4B67D468_00 +FFFFFFFFFFFFFFF8_5F7FFFFF_01 +007FFEFFFFFBFFFE_5AFFFDFF_01 +000000026CEC79F8_501B3B1E_01 +FFFFFFFFFFFFFFFC_5F7FFFFF_01 +00FFFFFF000000FF_5B7FFFFF_01 +0000000000D3983A_4B53983A_00 +FFFFFFFFFFFFFFFE_5F7FFFFF_01 +00007FFFBFFF7FFE_56FFFF7F_01 +00000001F4A7088A_4FFA5384_01 +FFFFFFFFFFFFFFFF_5F7FFFFF_01 +000008000000027E_55000000_01 +000000000001F4E8_47FA7400_00 +FFFFFFFFFFFFFFFD_5F7FFFFF_01 +FFFFFFFFFF83FFDF_5F7FFFFF_01 +00001E11407887B2_55F08A03_01 +FFFFFFFFFFFFFFFB_5F7FFFFF_01 +04000003FFFFFFF6_5C800000_01 +0000000000000D13_45513000_00 +FFFFFFFFFFFFFFF7_5F7FFFFF_01 +BFFC00000000003E_5F3FFC00_01 +00000028D7BBB75B_52235EEE_01 +FFFFFFFFFFFFFFEF_5F7FFFFF_01 +000FFFFBFFFC0000_597FFFBF_01 +0000000000CD5A23_4B4D5A23_00 +FFFFFFFFFFFFFFDF_5F7FFFFF_01 +FFBFDFFFBFFFFFFF_5F7FBFDF_01 +00000000000000FF_437F0000_00 +FFFFFFFFFFFFFFBF_5F7FFFFF_01 +00000007FF800003_50FFF000_01 +00000000000ABB02_492BB020_00 +FFFFFFFFFFFFFF7F_5F7FFFFF_01 +FFFFFFFFFFFEE7FF_5F7FFFFF_01 +00664B2B9BAD0DA2_5ACC9657_01 +FFFFFFFFFFFFFEFF_5F7FFFFF_01 +0000000000100803_49804018_00 +009B1DCB9F857D5E_5B1B1DCB_01 +FFFFFFFFFFFFFDFF_5F7FFFFF_01 +FFFFFFBFFFFFEFEE_5F7FFFFF_01 +36FD7542899C1C6F_5E5BF5D5_01 +FFFFFFFFFFFFFBFF_5F7FFFFF_01 +FF800000004001FF_5F7F8000_01 +0000000006BE4932_4CD7C926_01 +FFFFFFFFFFFFF7FF_5F7FFFFF_01 +00001004000FFFFE_55802000_01 +0000001DAA0123E0_51ED5009_01 +FFFFFFFFFFFFEFFF_5F7FFFFF_01 +00000001FDFFFDFE_4FFEFFFE_01 +00001C8703B1DCB0_55E4381D_01 +FFFFFFFFFFFFDFFF_5F7FFFFF_01 +FE0FE00000000000_5F7E0FE0_00 +0F79ED944A4E2779_5D779ED9_01 +FFFFFFFFFFFFBFFF_5F7FFFFF_01 +FBFFFE0400000000_5F7BFFFE_01 +0000030127E03666_544049F8_01 +FFFFFFFFFFFF7FFF_5F7FFFFF_01 +FFFFF0200000FFFE_5F7FFFF0_01 +000000000000017F_43BF8000_00 +FFFFFFFFFFFEFFFF_5F7FFFFF_01 +FFEFFE0000080000_5F7FEFFE_01 +00000000013354EA_4B99AA75_00 +FFFFFFFFFFFDFFFF_5F7FFFFF_01 +003FF0000003FFFE_5A7FC000_01 +0000016375B23F7B_53B1BAD9_01 +FFFFFFFFFFFBFFFF_5F7FFFFF_01 +000407FFFFFFFFF6_5880FFFF_01 +0000000192117F38_4FC908BF_01 +FFFFFFFFFFF7FFFF_5F7FFFFF_01 +FFFFFFFFFFFF7FFF_5F7FFFFF_01 +00000000000018BE_45C5F000_00 +FFFFFFFFFFEFFFFF_5F7FFFFF_01 +004000020FFFFFFF_5A800004_01 +0000B84C2D8BC9CB_57384C2D_01 +FFFFFFFFFFDFFFFF_5F7FFFFF_01 +00FFFFFFFFFFFFFD_5B7FFFFF_01 +00000223C2C6F284_5408F0B1_01 +FFFFFFFFFFBFFFFF_5F7FFFFF_01 +FFFDDFFFFFFFFFFD_5F7FFDDF_01 +00000000F46356C4_4F746356_01 +FFFFFFFFFF7FFFFF_5F7FFFFF_01 +010000000000BFFF_5B800000_01 +0000000000000005_40A00000_00 +FFFFFFFFFEFFFFFF_5F7FFFFF_01 +FFFFBF7FFBFFFFFE_5F7FFFBF_01 +00000026386CE889_5218E1B3_01 +FFFFFFFFFDFFFFFF_5F7FFFFF_01 +F00000F7FFFFFFFF_5F700000_01 +0001FC53090C46A4_57FE2984_01 +FFFFFFFFFBFFFFFF_5F7FFFFF_01 +0000000000800047_4B000047_00 +000000001693872E_4DB49C39_01 +FFFFFFFFF7FFFFFF_5F7FFFFF_01 +000000007FBFFBFF_4EFF7FF7_01 +00000226A7845E35_5409A9E1_01 +FFFFFFFFEFFFFFFF_5F7FFFFF_01 +FFFFFFDFFFFFFBFD_5F7FFFFF_01 +000000005433D14C_4EA867A2_01 +FFFFFFFFDFFFFFFF_5F7FFFFF_01 +0001FFFFFFE0000E_57FFFFFF_01 +00F23E8068D3D84A_5B723E80_01 +FFFFFFFFBFFFFFFF_5F7FFFFF_01 +F7FFBFFFFFFFBFFF_5F77FFBF_01 +0000BD29B7459087_573D29B7_01 +FFFFFFFF7FFFFFFF_5F7FFFFF_01 +FFFFFFF8FFFFBFFF_5F7FFFFF_01 +00000000002DDC06_4A377018_00 +FFFFFFFEFFFFFFFF_5F7FFFFF_01 +FFFFFFF80001FFFF_5F7FFFFF_01 +0000000000012FF9_4797FC80_00 +FFFFFFFDFFFFFFFF_5F7FFFFF_01 +004000040000FFFF_5A800008_01 +0000000000000001_3F800000_00 +FFFFFFFBFFFFFFFF_5F7FFFFF_01 +C0000000007FFFFA_5F400000_01 +0000000006053E2B_4CC0A7C5_01 +FFFFFFF7FFFFFFFF_5F7FFFFF_01 +7FFE000007FFFFFF_5EFFFC00_01 +000000000000002D_42340000_00 +FFFFFFEFFFFFFFFF_5F7FFFFF_01 +F80000000001007E_5F780000_01 +00000D48424AD9D6_55548424_01 +FFFFFFDFFFFFFFFF_5F7FFFFF_01 +FFFFFE0001FEFFFF_5F7FFFFE_01 +000000000000033B_444EC000_00 +FFFFFFBFFFFFFFFF_5F7FFFFF_01 +0007FBFFFFFDFFFE_58FF7FFF_01 +4A16BD4128090C83_5E942D7A_01 +FFFFFF7FFFFFFFFF_5F7FFFFF_01 +00FFF7FFFF7FFFFE_5B7FF7FF_01 +0000000000000086_43060000_00 +FFFFFEFFFFFFFFFF_5F7FFFFE_01 +FBFFFFBFFFBFFFFF_5F7BFFFF_01 +00000000000021BA_4606E800_00 +FFFFFDFFFFFFFFFF_5F7FFFFD_01 +0000000040000082_4E800001_01 +0007A2BF5B689F89_58F457EB_01 +FFFFFBFFFFFFFFFF_5F7FFFFB_01 +0000001FF8000008_51FFC000_01 +387CAA7DE672DE8B_5E61F2A9_01 +FFFFF7FFFFFFFFFF_5F7FFFF7_01 +07FFF80000000002_5CFFFF00_01 +0000000030A1E5B8_4E428796_01 +FFFFEFFFFFFFFFFF_5F7FFFEF_01 +F7FFFFE00007FFFF_5F77FFFF_01 +000000000006ADFC_48D5BF80_00 +FFFFDFFFFFFFFFFF_5F7FFFDF_01 +FFFFFF03FFFFFFC0_5F7FFFFF_01 +0A579475948F0032_5D257947_01 +FFFFBFFFFFFFFFFF_5F7FFFBF_01 +FC00000000003FF6_5F7C0000_01 +00AE677AC313BF60_5B2E677A_01 +FFFF7FFFFFFFFFFF_5F7FFF7F_01 +02000007FF7FFFFF_5C000001_01 +0000002E999639F1_523A6658_01 +FFFEFFFFFFFFFFFF_5F7FFEFF_01 +FFFF83FFFFFFFFBE_5F7FFF83_01 +000000000003537D_4854DF40_00 +FFFDFFFFFFFFFFFF_5F7FFDFF_01 +EFFFFFC00000003D_5F6FFFFF_01 +000000121FEDFD35_5190FF6F_01 +FFFBFFFFFFFFFFFF_5F7FFBFF_01 +FFFFFFF0000007FE_5F7FFFFF_01 +00000000001E0839_49F041C8_00 +FFF7FFFFFFFFFFFF_5F7FF7FF_01 +0000007FFFE000FF_52FFFFC0_01 +0000000079F30F48_4EF3E61E_01 +FFEFFFFFFFFFFFFF_5F7FEFFF_01 +FFFFFC13FFFFFFFD_5F7FFFFC_01 +0000000000003B85_466E1400_00 +FFDFFFFFFFFFFFFF_5F7FDFFF_01 +000008000007FFFE_55000000_01 +32DB4409E5AE87E6_5E4B6D10_01 +FFBFFFFFFFFFFFFF_5F7FBFFF_01 +FFFFFFFFFFF7BFEE_5F7FFFFF_01 +000000000000003D_42740000_00 +FF7FFFFFFFFFFFFF_5F7F7FFF_01 +000000001040FFFE_4D8207FF_01 +00004909A09C13D3_56921341_01 +FEFFFFFFFFFFFFFF_5F7EFFFF_01 +FFFFFF01FFFFFF7F_5F7FFFFF_01 +00000072E7D2575D_52E5CFA4_01 +FDFFFFFFFFFFFFFF_5F7DFFFF_01 +FFFFFFFFFFFEFFDB_5F7FFFFF_01 +0000000000000057_42AE0000_00 +FBFFFFFFFFFFFFFF_5F7BFFFF_01 +100000001FFFFFF6_5D800000_01 +000000914B12EF51_53114B12_01 +F7FFFFFFFFFFFFFF_5F77FFFF_01 +0407FFFFFFFFFEFF_5C80FFFF_01 +000000769F3A5C2C_52ED3E74_01 +EFFFFFFFFFFFFFFF_5F6FFFFF_01 +FFFFFFFDF7FFFFFD_5F7FFFFF_01 +0000000000000002_40000000_00 +DFFFFFFFFFFFFFFF_5F5FFFFF_01 +FFFFFFFFFE0007FF_5F7FFFFF_01 +000000000000009E_431E0000_00 +BFFFFFFFFFFFFFFF_5F3FFFFF_01 +FFF800000009FFFF_5F7FF800_01 +0000000000087AA4_4907AA40_00 +7FFFFFFFFFFFFFFF_5EFFFFFF_01 +4080000000FFFFFF_5E810000_01 +000000001DE7601D_4DEF3B00_01 +3FFFFFFFFFFFFFFF_5E7FFFFF_01 +FFCFFFFFFFBFFFFE_5F7FCFFF_01 +000000000000004A_42940000_00 +1FFFFFFFFFFFFFFF_5DFFFFFF_01 +000080400000003F_57004000_01 +00000000003F75A5_4A7DD694_00 +0FFFFFFFFFFFFFFF_5D7FFFFF_01 +FFFFFFEFFFFFCFFE_5F7FFFFF_01 +000000E775887420_53677588_01 +07FFFFFFFFFFFFFF_5CFFFFFF_01 +00000000000801FE_49001FE0_00 +0000000000A13FF1_4B213FF1_00 +03FFFFFFFFFFFFFF_5C7FFFFF_01 +07FEFFFFFFFFFFEE_5CFFDFFF_01 +000000000000000C_41400000_00 +01FFFFFFFFFFFFFF_5BFFFFFF_01 +0000000820000003_51020000_01 +00000001AD105214_4FD68829_01 +00FFFFFFFFFFFFFF_5B7FFFFF_01 +FFFFF00FFFFFFFBE_5F7FFFF0_01 +0000000000CC48E7_4B4C48E7_00 +007FFFFFFFFFFFFF_5AFFFFFF_01 +00000FFFEF7FFFFF_557FFEF7_01 +00000000000BA6CB_493A6CB0_00 +003FFFFFFFFFFFFF_5A7FFFFF_01 +FFFFFF7FBFFFFFBF_5F7FFFFF_01 +0000000000024425_48110940_00 +001FFFFFFFFFFFFF_59FFFFFF_01 +200000001FFBFFFF_5E000000_01 +0000004E7115EC53_529CE22B_01 +000FFFFFFFFFFFFF_597FFFFF_01 +FFFFF803FFFFFFBF_5F7FFFF8_01 +0000002E539ADCFE_52394E6B_01 +0007FFFFFFFFFFFF_58FFFFFF_01 +FFFFFFFFFBFFFFFF_5F7FFFFF_01 +000000D5084732F3_53550847_01 +0003FFFFFFFFFFFF_587FFFFF_01 +BFFF7FFFFFFFFE00_5F3FFF7F_01 +0000000000000543_44A86000_00 +0001FFFFFFFFFFFF_57FFFFFF_01 +0000001FFBFFE000_51FFDFFF_00 +000000000000491B_46923600_00 +0000FFFFFFFFFFFF_577FFFFF_01 +FC00200000001FFE_5F7C0020_01 +0000016898822A24_53B44C41_01 +00007FFFFFFFFFFF_56FFFFFF_01 +3FFF03FFFFFFFFFE_5E7FFC0F_01 +0000000FFE18C7BF_517FE18C_01 +00003FFFFFFFFFFF_567FFFFF_01 +FFFFFEFFFEFFFFFD_5F7FFFFE_01 +02F03620C1266ED9_5C3C0D88_01 +00001FFFFFFFFFFF_55FFFFFF_01 +BF7EFFFFFFFFFFFF_5F3F7EFF_01 +0000000000000055_42AA0000_00 +00000FFFFFFFFFFF_557FFFFF_01 +FFFBFFFFF803FFFE_5F7FFBFF_01 +0000000000168684_49B43420_00 +000007FFFFFFFFFF_54FFFFFF_01 +DFFFFFE00000001E_5F5FFFFF_01 +0000000000000CF5_454F5000_00 +000003FFFFFFFFFF_547FFFFF_01 +FFFF00400000FFFF_5F7FFF00_01 +0000000000000022_42080000_00 +000001FFFFFFFFFF_53FFFFFF_01 +FBFFFFFFFFFFBDFE_5F7BFFFF_01 +0000000000001BC9_45DE4800_00 +000000FFFFFFFFFF_537FFFFF_01 +807FFFFFFFFFDFFE_5F007FFF_01 +000274E35A70CD76_581D38D6_01 +0000007FFFFFFFFF_52FFFFFF_01 +0FFFFFFFFEFFFFFD_5D7FFFFF_01 +0000000300E73AFC_504039CE_01 +0000003FFFFFFFFF_527FFFFF_01 +FFC000000001000E_5F7FC000_01 +00000000000615E9_48C2BD20_00 +0000001FFFFFFFFF_51FFFFFF_01 +0001FFFFFFFFF3FD_57FFFFFF_01 +00000000000000B3_43330000_00 +0000000FFFFFFFFF_517FFFFF_01 +000000001FFFBFFF_4DFFFDFF_01 +0000006E6B141E1B_52DCD628_01 +00000007FFFFFFFF_50FFFFFF_01 +FFFFFFFFF60007FF_5F7FFFFF_01 +00000003AB310BA6_506ACC42_01 +00000003FFFFFFFF_507FFFFF_01 +0003FFFFB7FFFFFF_587FFFED_01 +0000000000000195_43CA8000_00 +00000001FFFFFFFF_4FFFFFFF_01 +FFFFFFFF8000000B_5F7FFFFF_01 +00000059BA8D5559_52B3751A_01 +00000000FFFFFFFF_4F7FFFFF_01 +FBFEFFFFFFFFFFF9_5F7BFEFF_01 +000001B6F062822D_53DB7831_01 +000000007FFFFFFF_4EFFFFFF_01 +0001000000000082_57800000_01 +03CEAD9E2FB104A4_5C73AB67_01 +000000003FFFFFFF_4E7FFFFF_01 +000003FFFFFFFF7C_547FFFFF_01 +000000000D681E78_4D5681E7_01 +000000001FFFFFFF_4DFFFFFF_01 +00002000400001FF_56000100_01 +0000000000000058_42B00000_00 +000000000FFFFFFF_4D7FFFFF_01 +3FFF80000000003E_5E7FFE00_01 +0000000000000095_43150000_00 +0000000007FFFFFF_4CFFFFFF_01 +010000BFFFFFFFFF_5B80005F_01 +0000009697087B19_53169708_01 +0000000003FFFFFF_4C7FFFFF_01 +FBFFFFFFFFEEFFFD_5F7BFFFF_01 +0000001E64BDFC55_51F325EF_01 +0000000001FFFFFF_4BFFFFFF_01 +FC00000001FFFFFE_5F7C0000_01 +0000D156A62AB849_575156A6_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_5F7FFFFF_01 +00035354EAE7C259_5854D53A_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_5F7FFFFF_01 +00000000F4DF3C75_4F74DF3C_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_5F7FFA00_01 +0000000000000003_40400000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_5F7FFFFF_01 +0000005B5433CB9B_52B6A867_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_5F7FFFFD_01 +0000000000DEAE1F_4B5EAE1F_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_5F7FFFFF_01 +000000007735DEC7_4EEE6BBD_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFDFFFF_01 +000007757D8B12ED_54EEAFB1_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_5F7FFFFE_01 +00002A654064E046_56299501_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000000_01 +0000000000000007_40E00000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5CFFFFFF_01 +00002D78B3D6C3B6_5635E2CF_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +000000070B77F34F_50E16EFE_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_5F7FFFFF_01 +0000093EB4D67EC8_5513EB4D_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_5F3FFFDF_01 +0205CEAF34EA1DC7_5C0173AB_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900000_01 +0000000000000003_40400000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000760D0_48EC1A00_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B801FFF_01 +02C000708FF1BA51_5C30001C_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_5F780200_01 +4F9E07DCC0BDC061_5E9F3C0F_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC000_01 +00000001B9B2A079_4FDCD950_01 +000000000000003F_427C0000_00 +FFF80000000080FF_5F7FF800_01 +00000000005EB5B4_4ABD6B68_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +0000000000DAC607_4B5AC607_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_5F7FFFFF_01 +00000DC5B9D66984_555C5B9D_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_5F4001FF_01 +00003D06B372AA06_56741ACD_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f32_rne.tv b/wally-pipelined/testbench/fp/ui64_f32_rne.tv new file mode 100644 index 000000000..552eb9882 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f32_rne.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_5CFFFFC0_01 +0000000072CC8B7A_4EE59917_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_5F800000_01 +072C857F319EDE38_5CE590B0_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_5F7FFFFC_01 +00794C79B6D3007B_5AF298F3_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_5F7C0000_01 +0000000005AE458D_4CB5C8B2_01 +0000000000000004_40800000_00 +00040008000007FE_58800100_01 +09EB456140D88764_5D1EB456_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_5F7FFFE4_01 +27DE834A248EDF36_5E1F7A0D_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC008_01 +00000000000385E2_48617880_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_5F700420_01 +000000159EB1FD45_51ACF590_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_5F800000_01 +000000000002DDFE_48377F80_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000002C89FF56B_503227FD_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF8_01 +3B5E4F0BE0DEBFF0_5E6D793C_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_5F7FFDF8_01 +000000000004766B_488ECD60_00 +0000000000000400_44800000_00 +0000080100000FFE_55001000_01 +000000000000002C_42300000_00 +0000000000000800_45000000_00 +0048000000100000_5A900000_01 +07E662A109109D0A_5CFCCC54_01 +0000000000001000_45800000_00 +C000000037FFFFFE_5F400000_01 +0000000000000064_42C80000_00 +0000000000002000_46000000_00 +F801000000100000_5F780100_01 +02114B79075F70EE_5C0452DE_01 +0000000000004000_46800000_00 +100000000001003E_5D800000_01 +0000000000000BAC_453AC000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000004_01 +000000C4A3A3DBE5_5344A3A4_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_5F7FE000_01 +0000000000001A91_45D48800_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_5F7FFFF8_01 +0000000000007309_46E61200_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF8_01 +0000000000000F58_45758000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_5F800000_01 +0000000000006980_46D30000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF080_01 +00000000000000DD_435D0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF80_01 +00008C23DA2CEAD8_570C23DA_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_5F600000_01 +00000DE3C1DEC43C_555E3C1E_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_5F7FFF00_01 +000000008030FFBE_4F003100_01 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_5F7FFE00_01 +000000000FDEED86_4D7DEED8_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_5F740000_01 +000000005DA3FF45_4EBB47FF_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_5F800000_01 +000000009B1BCB54_4F1B1BCB_01 +0000000008000000_4D000000_00 +00004000004001FE_56800001_01 +027DD19DE6563714_5C1F7467_01 +0000000010000000_4D800000_00 +FFC00000004007FE_5F7FC000_01 +000000000003A359_4868D640_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C700040_01 +000000003E62EC20_4E798BB0_01 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E800000_01 +000000000000685F_46D0BE00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_5F800000_01 +00000836F99DBAA8_55036F9A_01 +0000000100000000_4F800000_00 +00000020003FFEFE_52000100_01 +0073466832042D47_5AE68CD0_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_5F800000_01 +00000000007829C8_4AF05390_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_55800000_01 +0000001FB77C672B_51FDBBE3_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D000400_01 +0000000000005B78_46B6F000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_5F7F8000_01 +00000000000000F1_43710000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_55A00000_01 +0000000000000006_40C00000_00 +0000004000000000_52800000_00 +0800000000040800_5D000000_01 +0008A60D9E19F17E_590A60DA_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +0000000007506DBA_4CEA0DB7_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_5F800000_01 +0000000006A42AC9_4CD48559_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_55840000_01 +0007AA3F2BDACC89_58F547E5_01 +0000040000000000_54800000_00 +FFF8040000040000_5F7FF804_01 +0000000000000005_40A00000_00 +0000080000000000_55000000_00 +FFFF80000800001F_5F7FFF80_01 +000DF681DECDADC9_595F681E_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_5F7FFFFF_01 +0000000000004FBE_469F7C00_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51102000_01 +00C01FECA24DE1B0_5B401FED_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_5F780000_01 +0058A66761669936_5AB14CCF_01 +0000800000000000_57000000_00 +FFFEFF800000003E_5F7FFF00_01 +0716EA43FAC45C97_5CE2DD48_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_5F800000_01 +0064D70EC7661FD8_5AC9AE1E_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_5F408000_01 +00D956DBD0AEE817_5B5956DC_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FC_01 +0000000000004300_46860000_00 +0008000000000000_59000000_00 +4000000004002000_5E800000_01 +012EDF40F41F6021_5B976FA0_01 +0010000000000000_59800000_00 +FF9000000000001D_5F7F9000_01 +000000383DE950F6_5260F7A5_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_5F000004_01 +002B59CB3A604D69_5A2D672D_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5F000000_01 +000001A37C210862_53D1BE11_01 +0080000000000000_5B000000_00 +0002000002000002_58000001_01 +0000365CD8617789_56597362_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55E00000_01 +000000000000101D_4580E800_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800004_01 +000000001D098D19_4DE84C69_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C800000_01 +000016B3BD2C7BEF_55B59DE9_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFF00_01 +00004E5ADDDAA4A8_569CB5BC_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE00_01 +0000000000000721_44E42000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83C000_01 +0000000000648262_4AC904C4_00 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_5F400020_01 +0000007353AC45D2_52E6A759_01 +8000000000000000_5F000000_00 +FFFFFFFFFFE7EFFF_5F800000_01 +0000000001A1202D_4BD09016_01 +C000000000000000_5F400000_00 +FFFFFFFFFFFF5F7F_5F800000_01 +0000000000C0CA70_4B40CA70_00 +E000000000000000_5F600000_00 +0000200201FFFFFE_56000808_01 +00000007B55D87D4_50F6ABB1_01 +F000000000000000_5F700000_00 +FF80000DFFFFFFFF_5F7F8000_01 +000000090510FAEF_51105110_01 +F800000000000000_5F780000_00 +0003FFF00000000F_587FFC00_01 +000000000001724A_47B92500_00 +FC00000000000000_5F7C0000_00 +FFFFFFDF80000002_5F800000_01 +00000000000000E4_43640000_00 +FE00000000000000_5F7E0000_00 +FEFFFFFFFFF800FE_5F7F0000_01 +00000002C6222702_5031888A_01 +FF00000000000000_5F7F0000_00 +0000000408000002_50810000_01 +000002E96DF1CB41_543A5B7C_01 +FF80000000000000_5F7F8000_00 +007FFFFFFFFFF9FE_5B000000_01 +0727F174DEE7DC85_5CE4FE2F_01 +FFC0000000000000_5F7FC000_00 +8000000003FFFEFE_5F000000_01 +000000000010BD5B_4985EAD8_00 +FFE0000000000000_5F7FE000_00 +0BEFFFFFFFFFFFFF_5D3F0000_01 +000000000022790C_4A09E430_00 +FFF0000000000000_5F7FF000_00 +FFFFFFFFFFEFFBFA_5F800000_01 +000000369E75DF01_525A79D7_01 +FFF8000000000000_5F7FF800_00 +00000007FEFFDFFF_50FFDFFC_01 +000000000000001E_41F00000_00 +FFFC000000000000_5F7FFC00_00 +0003FFFE0007FFFE_587FFF80_01 +0000000000328622_4A4A1888_00 +FFFE000000000000_5F7FFE00_00 +FFFFFF7FFFFDF7FF_5F7FFFFF_01 +00172F0EC496FE21_59B97876_01 +FFFF000000000000_5F7FFF00_00 +DFBFFFFFFFFFFFFE_5F5FC000_01 +0000000004FC1FCA_4C9F83F9_01 +FFFF800000000000_5F7FFF80_00 +00000FFF800FFFFE_557FF801_01 +000F5194E4A9C2CE_5975194E_01 +FFFFC00000000000_5F7FFFC0_00 +00000002100007FD_50040002_01 +000000000002D8FE_48363F80_00 +FFFFE00000000000_5F7FFFE0_00 +000000000007FF6E_48FFEDC0_00 +000000000003766E_485D9B80_00 +FFFFF00000000000_5F7FFFF0_00 +0040000400000002_5A800008_01 +000000000000F841_47784100_00 +FFFFF80000000000_5F7FFFF8_00 +3DFFFFFFFFFFFF7E_5E780000_01 +0000000549E17E30_50A93C30_01 +FFFFFC0000000000_5F7FFFFC_00 +FFFFFFFFFFFFFEE1_5F800000_01 +0000000000000027_421C0000_00 +FFFFFE0000000000_5F7FFFFE_00 +000000000EFFFFDF_4D6FFFFE_01 +0000000000000373_445CC000_00 +FFFFFF0000000000_5F7FFFFF_00 +FD00000008000000_5F7D0000_01 +000000000005DBB1_48BB7620_00 +FFFFFF8000000000_5F800000_01 +FFFFFFFFFFF8007F_5F800000_01 +00000002FD10A515_503F4429_01 +FFFFFFC000000000_5F800000_01 +FFEFFFFFFFFFFFFE_5F7FF000_01 +0AB02984F6283B6C_5D2B0298_01 +FFFFFFE000000000_5F800000_01 +FFFFFFBC000001FE_5F800000_01 +00B087C6B9FE7FE0_5B3087C7_01 +FFFFFFF000000000_5F800000_01 +FFF80001000007FE_5F7FF800_01 +01F2762EA6837956_5BF93B17_01 +FFFFFFF800000000_5F800000_01 +FFF7E0FFFFFFFFFE_5F7FF7E1_01 +00022E1175484626_580B845D_01 +FFFFFFFC00000000_5F800000_01 +0000200020000FFE_56000080_01 +000000000000168F_45B47800_00 +FFFFFFFE00000000_5F800000_01 +021FFFFFFFFBFFFF_5C080000_01 +0000000000000001_3F800000_00 +FFFFFFFF00000000_5F800000_01 +FFFFFFD0000FFFFD_5F800000_01 +000001BDF6658B83_53DEFB33_01 +FFFFFFFF80000000_5F800000_01 +1000001FFDFFFFFF_5D800001_01 +000000000000BB5B_473B5B00_00 +FFFFFFFFC0000000_5F800000_01 +FFFFFFBFFE0FFFFF_5F800000_01 +0000000000000000_00000000_00 +FFFFFFFFE0000000_5F800000_01 +FFFFFFFBF00007FF_5F800000_01 +01E986274F48EAAD_5BF4C314_01 +FFFFFFFFF0000000_5F800000_01 +1FFFFFFDFFFFFF7F_5E000000_01 +000000000000CB5A_474B5A00_00 +FFFFFFFFF8000000_5F800000_01 +7FF000000000FFFF_5EFFE000_01 +0000000BC2717FC3_513C2718_01 +FFFFFFFFFC000000_5F800000_01 +FFFFFFE00008001F_5F800000_01 +00000000000FABDA_497ABDA0_00 +FFFFFFFFFE000000_5F800000_01 +0200000000000002_5C000000_01 +0000000000FDA53F_4B7DA53F_00 +FFFFFFFFFF000000_5F800000_01 +F6000003FFFFFFFE_5F760000_01 +0000000000000010_41800000_00 +FFFFFFFFFF800000_5F800000_01 +FFFFFFFFFFBFFF7E_5F800000_01 +00000001EE0FEA62_4FF707F5_01 +FFFFFFFFFFC00000_5F800000_01 +0000007FFF9FFFFD_52FFFF40_01 +00000077F35EDC1D_52EFE6BE_01 +FFFFFFFFFFE00000_5F800000_01 +FFFFFFF7FDFFFF7D_5F800000_01 +00000000000003AD_446B4000_00 +FFFFFFFFFFF00000_5F800000_01 +FFFFFF0000100020_5F7FFFFF_01 +67F167FBC7FC5F9A_5ECFE2D0_01 +FFFFFFFFFFF80000_5F800000_01 +003FFFFFFFFC0001_5A800000_01 +002E48F9F4EBD30E_5A3923E8_01 +FFFFFFFFFFFC0000_5F800000_01 +DFFFFFFFFFFBFFFE_5F600000_01 +0091C23EE8C9424F_5B11C23F_01 +FFFFFFFFFFFE0000_5F800000_01 +F7DFFBFFFFFFFFFE_5F77DFFC_01 +00000000ACAE080C_4F2CAE08_01 +FFFFFFFFFFFF0000_5F800000_01 +FFFFC00010000020_5F7FFFC0_01 +0CD921F917B20E40_5D4D9220_01 +FFFFFFFFFFFF8000_5F800000_01 +F8000FFFFFFFFFFD_5F780010_01 +00017C566BC7D811_57BE2B36_01 +FFFFFFFFFFFFC000_5F800000_01 +00000000000000FE_437E0000_00 +00F82AC14930D386_5B782AC1_01 +FFFFFFFFFFFFE000_5F800000_01 +00000000000003FC_447F0000_00 +008E62EC60E119FC_5B0E62EC_01 +FFFFFFFFFFFFF000_5F800000_01 +FFFFEFF7FF7FFFFE_5F7FFFF0_01 +1E2B1ECF210EEDC5_5DF158F6_01 +FFFFFFFFFFFFF800_5F800000_01 +00000000007FFF1F_4AFFFE3E_00 +000006534F5676F7_54CA69EB_01 +FFFFFFFFFFFFFC00_5F800000_01 +0000001004FFFFFD_51802800_01 +0000435C939669F1_5686B927_01 +FFFFFFFFFFFFFE00_5F800000_01 +1FFFFFFFFFFFFDFD_5E000000_01 +0000000000000011_41880000_00 +FFFFFFFFFFFFFF00_5F800000_01 +01FFFFFFFBFFEFFE_5C000000_01 +000000000000036E_445B8000_00 +FFFFFFFFFFFFFF80_5F800000_01 +FFF7FFFFFFFFF7FD_5F7FF800_01 +000038E2BCFAC553_56638AF4_01 +FFFFFFFFFFFFFFC0_5F800000_01 +FFFFFBFFFFFE0FFE_5F7FFFFC_01 +00000009A4E704BF_511A4E70_01 +FFFFFFFFFFFFFFE0_5F800000_01 +1400007FFFFFFFFD_5DA00004_01 +0000000093B187B4_4F13B188_01 +FFFFFFFFFFFFFFF0_5F800000_01 +40000000007FFFFD_5E800000_01 +0000000000E7D468_4B67D468_00 +FFFFFFFFFFFFFFF8_5F800000_01 +007FFEFFFFFBFFFE_5AFFFE00_01 +000000026CEC79F8_501B3B1E_01 +FFFFFFFFFFFFFFFC_5F800000_01 +00FFFFFF000000FF_5B7FFFFF_01 +0000000000D3983A_4B53983A_00 +FFFFFFFFFFFFFFFE_5F800000_01 +00007FFFBFFF7FFE_56FFFF80_01 +00000001F4A7088A_4FFA5384_01 +FFFFFFFFFFFFFFFF_5F800000_01 +000008000000027E_55000000_01 +000000000001F4E8_47FA7400_00 +FFFFFFFFFFFFFFFD_5F800000_01 +FFFFFFFFFF83FFDF_5F800000_01 +00001E11407887B2_55F08A04_01 +FFFFFFFFFFFFFFFB_5F800000_01 +04000003FFFFFFF6_5C800000_01 +0000000000000D13_45513000_00 +FFFFFFFFFFFFFFF7_5F800000_01 +BFFC00000000003E_5F3FFC00_01 +00000028D7BBB75B_52235EEF_01 +FFFFFFFFFFFFFFEF_5F800000_01 +000FFFFBFFFC0000_597FFFC0_01 +0000000000CD5A23_4B4D5A23_00 +FFFFFFFFFFFFFFDF_5F800000_01 +FFBFDFFFBFFFFFFF_5F7FBFE0_01 +00000000000000FF_437F0000_00 +FFFFFFFFFFFFFFBF_5F800000_01 +00000007FF800003_50FFF000_01 +00000000000ABB02_492BB020_00 +FFFFFFFFFFFFFF7F_5F800000_01 +FFFFFFFFFFFEE7FF_5F800000_01 +00664B2B9BAD0DA2_5ACC9657_01 +FFFFFFFFFFFFFEFF_5F800000_01 +0000000000100803_49804018_00 +009B1DCB9F857D5E_5B1B1DCC_01 +FFFFFFFFFFFFFDFF_5F800000_01 +FFFFFFBFFFFFEFEE_5F800000_01 +36FD7542899C1C6F_5E5BF5D5_01 +FFFFFFFFFFFFFBFF_5F800000_01 +FF800000004001FF_5F7F8000_01 +0000000006BE4932_4CD7C926_01 +FFFFFFFFFFFFF7FF_5F800000_01 +00001004000FFFFE_55802000_01 +0000001DAA0123E0_51ED5009_01 +FFFFFFFFFFFFEFFF_5F800000_01 +00000001FDFFFDFE_4FFEFFFF_01 +00001C8703B1DCB0_55E4381E_01 +FFFFFFFFFFFFDFFF_5F800000_01 +FE0FE00000000000_5F7E0FE0_00 +0F79ED944A4E2779_5D779ED9_01 +FFFFFFFFFFFFBFFF_5F800000_01 +FBFFFE0400000000_5F7BFFFE_01 +0000030127E03666_544049F8_01 +FFFFFFFFFFFF7FFF_5F800000_01 +FFFFF0200000FFFE_5F7FFFF0_01 +000000000000017F_43BF8000_00 +FFFFFFFFFFFEFFFF_5F800000_01 +FFEFFE0000080000_5F7FEFFE_01 +00000000013354EA_4B99AA75_00 +FFFFFFFFFFFDFFFF_5F800000_01 +003FF0000003FFFE_5A7FC000_01 +0000016375B23F7B_53B1BAD9_01 +FFFFFFFFFFFBFFFF_5F800000_01 +000407FFFFFFFFF6_58810000_01 +0000000192117F38_4FC908C0_01 +FFFFFFFFFFF7FFFF_5F800000_01 +FFFFFFFFFFFF7FFF_5F800000_01 +00000000000018BE_45C5F000_00 +FFFFFFFFFFEFFFFF_5F800000_01 +004000020FFFFFFF_5A800004_01 +0000B84C2D8BC9CB_57384C2E_01 +FFFFFFFFFFDFFFFF_5F800000_01 +00FFFFFFFFFFFFFD_5B800000_01 +00000223C2C6F284_5408F0B2_01 +FFFFFFFFFFBFFFFF_5F800000_01 +FFFDDFFFFFFFFFFD_5F7FFDE0_01 +00000000F46356C4_4F746357_01 +FFFFFFFFFF7FFFFF_5F800000_01 +010000000000BFFF_5B800000_01 +0000000000000005_40A00000_00 +FFFFFFFFFEFFFFFF_5F800000_01 +FFFFBF7FFBFFFFFE_5F7FFFBF_01 +00000026386CE889_5218E1B4_01 +FFFFFFFFFDFFFFFF_5F800000_01 +F00000F7FFFFFFFF_5F700001_01 +0001FC53090C46A4_57FE2985_01 +FFFFFFFFFBFFFFFF_5F800000_01 +0000000000800047_4B000047_00 +000000001693872E_4DB49C39_01 +FFFFFFFFF7FFFFFF_5F800000_01 +000000007FBFFBFF_4EFF7FF8_01 +00000226A7845E35_5409A9E1_01 +FFFFFFFFEFFFFFFF_5F800000_01 +FFFFFFDFFFFFFBFD_5F800000_01 +000000005433D14C_4EA867A3_01 +FFFFFFFFDFFFFFFF_5F800000_01 +0001FFFFFFE0000E_58000000_01 +00F23E8068D3D84A_5B723E80_01 +FFFFFFFFBFFFFFFF_5F800000_01 +F7FFBFFFFFFFBFFF_5F77FFC0_01 +0000BD29B7459087_573D29B7_01 +FFFFFFFF7FFFFFFF_5F800000_01 +FFFFFFF8FFFFBFFF_5F800000_01 +00000000002DDC06_4A377018_00 +FFFFFFFEFFFFFFFF_5F800000_01 +FFFFFFF80001FFFF_5F800000_01 +0000000000012FF9_4797FC80_00 +FFFFFFFDFFFFFFFF_5F800000_01 +004000040000FFFF_5A800008_01 +0000000000000001_3F800000_00 +FFFFFFFBFFFFFFFF_5F800000_01 +C0000000007FFFFA_5F400000_01 +0000000006053E2B_4CC0A7C5_01 +FFFFFFF7FFFFFFFF_5F800000_01 +7FFE000007FFFFFF_5EFFFC00_01 +000000000000002D_42340000_00 +FFFFFFEFFFFFFFFF_5F800000_01 +F80000000001007E_5F780000_01 +00000D48424AD9D6_55548425_01 +FFFFFFDFFFFFFFFF_5F800000_01 +FFFFFE0001FEFFFF_5F7FFFFE_01 +000000000000033B_444EC000_00 +FFFFFFBFFFFFFFFF_5F800000_01 +0007FBFFFFFDFFFE_58FF8000_01 +4A16BD4128090C83_5E942D7B_01 +FFFFFF7FFFFFFFFF_5F7FFFFF_01 +00FFF7FFFF7FFFFE_5B7FF800_01 +0000000000000086_43060000_00 +FFFFFEFFFFFFFFFF_5F7FFFFF_01 +FBFFFFBFFFBFFFFF_5F7C0000_01 +00000000000021BA_4606E800_00 +FFFFFDFFFFFFFFFF_5F7FFFFE_01 +0000000040000082_4E800001_01 +0007A2BF5B689F89_58F457EB_01 +FFFFFBFFFFFFFFFF_5F7FFFFC_01 +0000001FF8000008_51FFC000_01 +387CAA7DE672DE8B_5E61F2AA_01 +FFFFF7FFFFFFFFFF_5F7FFFF8_01 +07FFF80000000002_5CFFFF00_01 +0000000030A1E5B8_4E428797_01 +FFFFEFFFFFFFFFFF_5F7FFFF0_01 +F7FFFFE00007FFFF_5F780000_01 +000000000006ADFC_48D5BF80_00 +FFFFDFFFFFFFFFFF_5F7FFFE0_01 +FFFFFF03FFFFFFC0_5F7FFFFF_01 +0A579475948F0032_5D257947_01 +FFFFBFFFFFFFFFFF_5F7FFFC0_01 +FC00000000003FF6_5F7C0000_01 +00AE677AC313BF60_5B2E677B_01 +FFFF7FFFFFFFFFFF_5F7FFF80_01 +02000007FF7FFFFF_5C000002_01 +0000002E999639F1_523A6659_01 +FFFEFFFFFFFFFFFF_5F7FFF00_01 +FFFF83FFFFFFFFBE_5F7FFF84_01 +000000000003537D_4854DF40_00 +FFFDFFFFFFFFFFFF_5F7FFE00_01 +EFFFFFC00000003D_5F700000_01 +000000121FEDFD35_5190FF70_01 +FFFBFFFFFFFFFFFF_5F7FFC00_01 +FFFFFFF0000007FE_5F800000_01 +00000000001E0839_49F041C8_00 +FFF7FFFFFFFFFFFF_5F7FF800_01 +0000007FFFE000FF_52FFFFC0_01 +0000000079F30F48_4EF3E61F_01 +FFEFFFFFFFFFFFFF_5F7FF000_01 +FFFFFC13FFFFFFFD_5F7FFFFC_01 +0000000000003B85_466E1400_00 +FFDFFFFFFFFFFFFF_5F7FE000_01 +000008000007FFFE_55000000_01 +32DB4409E5AE87E6_5E4B6D10_01 +FFBFFFFFFFFFFFFF_5F7FC000_01 +FFFFFFFFFFF7BFEE_5F800000_01 +000000000000003D_42740000_00 +FF7FFFFFFFFFFFFF_5F7F8000_01 +000000001040FFFE_4D820800_01 +00004909A09C13D3_56921341_01 +FEFFFFFFFFFFFFFF_5F7F0000_01 +FFFFFF01FFFFFF7F_5F7FFFFF_01 +00000072E7D2575D_52E5CFA5_01 +FDFFFFFFFFFFFFFF_5F7E0000_01 +FFFFFFFFFFFEFFDB_5F800000_01 +0000000000000057_42AE0000_00 +FBFFFFFFFFFFFFFF_5F7C0000_01 +100000001FFFFFF6_5D800000_01 +000000914B12EF51_53114B13_01 +F7FFFFFFFFFFFFFF_5F780000_01 +0407FFFFFFFFFEFF_5C810000_01 +000000769F3A5C2C_52ED3E75_01 +EFFFFFFFFFFFFFFF_5F700000_01 +FFFFFFFDF7FFFFFD_5F800000_01 +0000000000000002_40000000_00 +DFFFFFFFFFFFFFFF_5F600000_01 +FFFFFFFFFE0007FF_5F800000_01 +000000000000009E_431E0000_00 +BFFFFFFFFFFFFFFF_5F400000_01 +FFF800000009FFFF_5F7FF800_01 +0000000000087AA4_4907AA40_00 +7FFFFFFFFFFFFFFF_5F000000_01 +4080000000FFFFFF_5E810000_01 +000000001DE7601D_4DEF3B01_01 +3FFFFFFFFFFFFFFF_5E800000_01 +FFCFFFFFFFBFFFFE_5F7FD000_01 +000000000000004A_42940000_00 +1FFFFFFFFFFFFFFF_5E000000_01 +000080400000003F_57004000_01 +00000000003F75A5_4A7DD694_00 +0FFFFFFFFFFFFFFF_5D800000_01 +FFFFFFEFFFFFCFFE_5F800000_01 +000000E775887420_53677588_01 +07FFFFFFFFFFFFFF_5D000000_01 +00000000000801FE_49001FE0_00 +0000000000A13FF1_4B213FF1_00 +03FFFFFFFFFFFFFF_5C800000_01 +07FEFFFFFFFFFFEE_5CFFE000_01 +000000000000000C_41400000_00 +01FFFFFFFFFFFFFF_5C000000_01 +0000000820000003_51020000_01 +00000001AD105214_4FD68829_01 +00FFFFFFFFFFFFFF_5B800000_01 +FFFFF00FFFFFFFBE_5F7FFFF0_01 +0000000000CC48E7_4B4C48E7_00 +007FFFFFFFFFFFFF_5B000000_01 +00000FFFEF7FFFFF_557FFEF8_01 +00000000000BA6CB_493A6CB0_00 +003FFFFFFFFFFFFF_5A800000_01 +FFFFFF7FBFFFFFBF_5F7FFFFF_01 +0000000000024425_48110940_00 +001FFFFFFFFFFFFF_5A000000_01 +200000001FFBFFFF_5E000000_01 +0000004E7115EC53_529CE22C_01 +000FFFFFFFFFFFFF_59800000_01 +FFFFF803FFFFFFBF_5F7FFFF8_01 +0000002E539ADCFE_52394E6B_01 +0007FFFFFFFFFFFF_59000000_01 +FFFFFFFFFBFFFFFF_5F800000_01 +000000D5084732F3_53550847_01 +0003FFFFFFFFFFFF_58800000_01 +BFFF7FFFFFFFFE00_5F3FFF80_01 +0000000000000543_44A86000_00 +0001FFFFFFFFFFFF_58000000_01 +0000001FFBFFE000_51FFDFFF_00 +000000000000491B_46923600_00 +0000FFFFFFFFFFFF_57800000_01 +FC00200000001FFE_5F7C0020_01 +0000016898822A24_53B44C41_01 +00007FFFFFFFFFFF_57000000_01 +3FFF03FFFFFFFFFE_5E7FFC10_01 +0000000FFE18C7BF_517FE18C_01 +00003FFFFFFFFFFF_56800000_01 +FFFFFEFFFEFFFFFD_5F7FFFFF_01 +02F03620C1266ED9_5C3C0D88_01 +00001FFFFFFFFFFF_56000000_01 +BF7EFFFFFFFFFFFF_5F3F7F00_01 +0000000000000055_42AA0000_00 +00000FFFFFFFFFFF_55800000_01 +FFFBFFFFF803FFFE_5F7FFC00_01 +0000000000168684_49B43420_00 +000007FFFFFFFFFF_55000000_01 +DFFFFFE00000001E_5F600000_01 +0000000000000CF5_454F5000_00 +000003FFFFFFFFFF_54800000_01 +FFFF00400000FFFF_5F7FFF00_01 +0000000000000022_42080000_00 +000001FFFFFFFFFF_54000000_01 +FBFFFFFFFFFFBDFE_5F7C0000_01 +0000000000001BC9_45DE4800_00 +000000FFFFFFFFFF_53800000_01 +807FFFFFFFFFDFFE_5F008000_01 +000274E35A70CD76_581D38D7_01 +0000007FFFFFFFFF_53000000_01 +0FFFFFFFFEFFFFFD_5D800000_01 +0000000300E73AFC_504039CF_01 +0000003FFFFFFFFF_52800000_01 +FFC000000001000E_5F7FC000_01 +00000000000615E9_48C2BD20_00 +0000001FFFFFFFFF_52000000_01 +0001FFFFFFFFF3FD_58000000_01 +00000000000000B3_43330000_00 +0000000FFFFFFFFF_51800000_01 +000000001FFFBFFF_4DFFFE00_01 +0000006E6B141E1B_52DCD628_01 +00000007FFFFFFFF_51000000_01 +FFFFFFFFF60007FF_5F800000_01 +00000003AB310BA6_506ACC43_01 +00000003FFFFFFFF_50800000_01 +0003FFFFB7FFFFFF_587FFFEE_01 +0000000000000195_43CA8000_00 +00000001FFFFFFFF_50000000_01 +FFFFFFFF8000000B_5F800000_01 +00000059BA8D5559_52B3751B_01 +00000000FFFFFFFF_4F800000_01 +FBFEFFFFFFFFFFF9_5F7BFF00_01 +000001B6F062822D_53DB7831_01 +000000007FFFFFFF_4F000000_01 +0001000000000082_57800000_01 +03CEAD9E2FB104A4_5C73AB68_01 +000000003FFFFFFF_4E800000_01 +000003FFFFFFFF7C_54800000_01 +000000000D681E78_4D5681E8_01 +000000001FFFFFFF_4E000000_01 +00002000400001FF_56000100_01 +0000000000000058_42B00000_00 +000000000FFFFFFF_4D800000_01 +3FFF80000000003E_5E7FFE00_01 +0000000000000095_43150000_00 +0000000007FFFFFF_4D000000_01 +010000BFFFFFFFFF_5B800060_01 +0000009697087B19_53169708_01 +0000000003FFFFFF_4C800000_01 +FBFFFFFFFFEEFFFD_5F7C0000_01 +0000001E64BDFC55_51F325F0_01 +0000000001FFFFFF_4C000000_01 +FC00000001FFFFFE_5F7C0000_01 +0000D156A62AB849_575156A6_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_5F800000_01 +00035354EAE7C259_5854D53B_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_5F800000_01 +00000000F4DF3C75_4F74DF3C_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_5F7FFA00_01 +0000000000000003_40400000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_5F800000_01 +0000005B5433CB9B_52B6A868_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_5F7FFFFE_01 +0000000000DEAE1F_4B5EAE1F_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_5F800000_01 +000000007735DEC7_4EEE6BBE_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFE0000_01 +000007757D8B12ED_54EEAFB1_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_5F7FFFFE_01 +00002A654064E046_56299502_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000000_01 +0000000000000007_40E00000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5D000000_01 +00002D78B3D6C3B6_5635E2CF_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +000000070B77F34F_50E16EFE_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_5F800000_01 +0000093EB4D67EC8_5513EB4D_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_5F3FFFE0_01 +0205CEAF34EA1DC7_5C0173AC_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900001_01 +0000000000000003_40400000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000760D0_48EC1A00_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B802000_01 +02C000708FF1BA51_5C30001C_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_5F780200_01 +4F9E07DCC0BDC061_5E9F3C10_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC000_01 +00000001B9B2A079_4FDCD950_01 +000000000000003F_427C0000_00 +FFF80000000080FF_5F7FF800_01 +00000000005EB5B4_4ABD6B68_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +0000000000DAC607_4B5AC607_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_5F800000_01 +00000DC5B9D66984_555C5B9D_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_5F400200_01 +00003D06B372AA06_56741ACE_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f32_ru.tv b/wally-pipelined/testbench/fp/ui64_f32_ru.tv new file mode 100644 index 000000000..acf27f8c5 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f32_ru.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_5CFFFFC0_01 +0000000072CC8B7A_4EE59917_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_5F800000_01 +072C857F319EDE38_5CE590B0_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_5F7FFFFC_01 +00794C79B6D3007B_5AF298F4_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_5F7C0000_01 +0000000005AE458D_4CB5C8B2_01 +0000000000000004_40800000_00 +00040008000007FE_58800101_01 +09EB456140D88764_5D1EB457_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_5F7FFFE5_01 +27DE834A248EDF36_5E1F7A0E_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC008_01 +00000000000385E2_48617880_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_5F700420_01 +000000159EB1FD45_51ACF590_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_5F800000_01 +000000000002DDFE_48377F80_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000002C89FF56B_503227FE_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF8_01 +3B5E4F0BE0DEBFF0_5E6D793D_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_5F7FFDF9_01 +000000000004766B_488ECD60_00 +0000000000000400_44800000_00 +0000080100000FFE_55001001_01 +000000000000002C_42300000_00 +0000000000000800_45000000_00 +0048000000100000_5A900001_01 +07E662A109109D0A_5CFCCC55_01 +0000000000001000_45800000_00 +C000000037FFFFFE_5F400001_01 +0000000000000064_42C80000_00 +0000000000002000_46000000_00 +F801000000100000_5F780101_01 +02114B79075F70EE_5C0452DF_01 +0000000000004000_46800000_00 +100000000001003E_5D800001_01 +0000000000000BAC_453AC000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000004_01 +000000C4A3A3DBE5_5344A3A4_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_5F7FE001_01 +0000000000001A91_45D48800_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_5F7FFFF8_01 +0000000000007309_46E61200_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF8_01 +0000000000000F58_45758000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_5F800000_01 +0000000000006980_46D30000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF080_01 +00000000000000DD_435D0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF80_01 +00008C23DA2CEAD8_570C23DB_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_5F600001_01 +00000DE3C1DEC43C_555E3C1E_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_5F7FFF01_01 +000000008030FFBE_4F003100_01 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_5F7FFE01_01 +000000000FDEED86_4D7DEED9_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_5F740000_01 +000000005DA3FF45_4EBB47FF_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_5F800000_01 +000000009B1BCB54_4F1B1BCC_01 +0000000008000000_4D000000_00 +00004000004001FE_56800001_01 +027DD19DE6563714_5C1F7468_01 +0000000010000000_4D800000_00 +FFC00000004007FE_5F7FC001_01 +000000000003A359_4868D640_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C700040_01 +000000003E62EC20_4E798BB1_01 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E800000_01 +000000000000685F_46D0BE00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_5F800000_01 +00000836F99DBAA8_55036F9A_01 +0000000100000000_4F800000_00 +00000020003FFEFE_52000100_01 +0073466832042D47_5AE68CD1_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_5F800000_01 +00000000007829C8_4AF05390_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_55800000_01 +0000001FB77C672B_51FDBBE4_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D000400_01 +0000000000005B78_46B6F000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_5F7F8000_01 +00000000000000F1_43710000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_55A00000_01 +0000000000000006_40C00000_00 +0000004000000000_52800000_00 +0800000000040800_5D000001_01 +0008A60D9E19F17E_590A60DA_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +0000000007506DBA_4CEA0DB8_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_5F800000_01 +0000000006A42AC9_4CD4855A_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_55840000_01 +0007AA3F2BDACC89_58F547E6_01 +0000040000000000_54800000_00 +FFF8040000040000_5F7FF805_01 +0000000000000005_40A00000_00 +0000080000000000_55000000_00 +FFFF80000800001F_5F7FFF81_01 +000DF681DECDADC9_595F681E_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_5F7FFFFF_01 +0000000000004FBE_469F7C00_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51102000_01 +00C01FECA24DE1B0_5B401FED_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_5F780000_01 +0058A66761669936_5AB14CCF_01 +0000800000000000_57000000_00 +FFFEFF800000003E_5F7FFF00_01 +0716EA43FAC45C97_5CE2DD49_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_5F800000_01 +0064D70EC7661FD8_5AC9AE1E_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_5F408000_01 +00D956DBD0AEE817_5B5956DC_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FC_01 +0000000000004300_46860000_00 +0008000000000000_59000000_00 +4000000004002000_5E800001_01 +012EDF40F41F6021_5B976FA1_01 +0010000000000000_59800000_00 +FF9000000000001D_5F7F9001_01 +000000383DE950F6_5260F7A6_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_5F000004_01 +002B59CB3A604D69_5A2D672D_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5F000000_01 +000001A37C210862_53D1BE11_01 +0080000000000000_5B000000_00 +0002000002000002_58000001_01 +0000365CD8617789_56597362_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55E00000_01 +000000000000101D_4580E800_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800005_01 +000000001D098D19_4DE84C69_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C800000_01 +000016B3BD2C7BEF_55B59DEA_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFF00_01 +00004E5ADDDAA4A8_569CB5BC_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE01_01 +0000000000000721_44E42000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83C000_01 +0000000000648262_4AC904C4_00 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_5F400020_01 +0000007353AC45D2_52E6A759_01 +8000000000000000_5F000000_00 +FFFFFFFFFFE7EFFF_5F800000_01 +0000000001A1202D_4BD09017_01 +C000000000000000_5F400000_00 +FFFFFFFFFFFF5F7F_5F800000_01 +0000000000C0CA70_4B40CA70_00 +E000000000000000_5F600000_00 +0000200201FFFFFE_56000808_01 +00000007B55D87D4_50F6ABB1_01 +F000000000000000_5F700000_00 +FF80000DFFFFFFFF_5F7F8001_01 +000000090510FAEF_51105110_01 +F800000000000000_5F780000_00 +0003FFF00000000F_587FFC01_01 +000000000001724A_47B92500_00 +FC00000000000000_5F7C0000_00 +FFFFFFDF80000002_5F800000_01 +00000000000000E4_43640000_00 +FE00000000000000_5F7E0000_00 +FEFFFFFFFFF800FE_5F7F0000_01 +00000002C6222702_5031888A_01 +FF00000000000000_5F7F0000_00 +0000000408000002_50810001_01 +000002E96DF1CB41_543A5B7D_01 +FF80000000000000_5F7F8000_00 +007FFFFFFFFFF9FE_5B000000_01 +0727F174DEE7DC85_5CE4FE2F_01 +FFC0000000000000_5F7FC000_00 +8000000003FFFEFE_5F000001_01 +000000000010BD5B_4985EAD8_00 +FFE0000000000000_5F7FE000_00 +0BEFFFFFFFFFFFFF_5D3F0000_01 +000000000022790C_4A09E430_00 +FFF0000000000000_5F7FF000_00 +FFFFFFFFFFEFFBFA_5F800000_01 +000000369E75DF01_525A79D8_01 +FFF8000000000000_5F7FF800_00 +00000007FEFFDFFF_50FFDFFC_01 +000000000000001E_41F00000_00 +FFFC000000000000_5F7FFC00_00 +0003FFFE0007FFFE_587FFF81_01 +0000000000328622_4A4A1888_00 +FFFE000000000000_5F7FFE00_00 +FFFFFF7FFFFDF7FF_5F800000_01 +00172F0EC496FE21_59B97877_01 +FFFF000000000000_5F7FFF00_00 +DFBFFFFFFFFFFFFE_5F5FC000_01 +0000000004FC1FCA_4C9F83FA_01 +FFFF800000000000_5F7FFF80_00 +00000FFF800FFFFE_557FF801_01 +000F5194E4A9C2CE_5975194F_01 +FFFFC00000000000_5F7FFFC0_00 +00000002100007FD_50040002_01 +000000000002D8FE_48363F80_00 +FFFFE00000000000_5F7FFFE0_00 +000000000007FF6E_48FFEDC0_00 +000000000003766E_485D9B80_00 +FFFFF00000000000_5F7FFFF0_00 +0040000400000002_5A800009_01 +000000000000F841_47784100_00 +FFFFF80000000000_5F7FFFF8_00 +3DFFFFFFFFFFFF7E_5E780000_01 +0000000549E17E30_50A93C30_01 +FFFFFC0000000000_5F7FFFFC_00 +FFFFFFFFFFFFFEE1_5F800000_01 +0000000000000027_421C0000_00 +FFFFFE0000000000_5F7FFFFE_00 +000000000EFFFFDF_4D6FFFFE_01 +0000000000000373_445CC000_00 +FFFFFF0000000000_5F7FFFFF_00 +FD00000008000000_5F7D0001_01 +000000000005DBB1_48BB7620_00 +FFFFFF8000000000_5F800000_01 +FFFFFFFFFFF8007F_5F800000_01 +00000002FD10A515_503F442A_01 +FFFFFFC000000000_5F800000_01 +FFEFFFFFFFFFFFFE_5F7FF000_01 +0AB02984F6283B6C_5D2B0299_01 +FFFFFFE000000000_5F800000_01 +FFFFFFBC000001FE_5F800000_01 +00B087C6B9FE7FE0_5B3087C7_01 +FFFFFFF000000000_5F800000_01 +FFF80001000007FE_5F7FF801_01 +01F2762EA6837956_5BF93B18_01 +FFFFFFF800000000_5F800000_01 +FFF7E0FFFFFFFFFE_5F7FF7E1_01 +00022E1175484626_580B845E_01 +FFFFFFFC00000000_5F800000_01 +0000200020000FFE_56000081_01 +000000000000168F_45B47800_00 +FFFFFFFE00000000_5F800000_01 +021FFFFFFFFBFFFF_5C080000_01 +0000000000000001_3F800000_00 +FFFFFFFF00000000_5F800000_01 +FFFFFFD0000FFFFD_5F800000_01 +000001BDF6658B83_53DEFB33_01 +FFFFFFFF80000000_5F800000_01 +1000001FFDFFFFFF_5D800001_01 +000000000000BB5B_473B5B00_00 +FFFFFFFFC0000000_5F800000_01 +FFFFFFBFFE0FFFFF_5F800000_01 +0000000000000000_00000000_00 +FFFFFFFFE0000000_5F800000_01 +FFFFFFFBF00007FF_5F800000_01 +01E986274F48EAAD_5BF4C314_01 +FFFFFFFFF0000000_5F800000_01 +1FFFFFFDFFFFFF7F_5E000000_01 +000000000000CB5A_474B5A00_00 +FFFFFFFFF8000000_5F800000_01 +7FF000000000FFFF_5EFFE001_01 +0000000BC2717FC3_513C2718_01 +FFFFFFFFFC000000_5F800000_01 +FFFFFFE00008001F_5F800000_01 +00000000000FABDA_497ABDA0_00 +FFFFFFFFFE000000_5F800000_01 +0200000000000002_5C000001_01 +0000000000FDA53F_4B7DA53F_00 +FFFFFFFFFF000000_5F800000_01 +F6000003FFFFFFFE_5F760001_01 +0000000000000010_41800000_00 +FFFFFFFFFF800000_5F800000_01 +FFFFFFFFFFBFFF7E_5F800000_01 +00000001EE0FEA62_4FF707F6_01 +FFFFFFFFFFC00000_5F800000_01 +0000007FFF9FFFFD_52FFFF40_01 +00000077F35EDC1D_52EFE6BE_01 +FFFFFFFFFFE00000_5F800000_01 +FFFFFFF7FDFFFF7D_5F800000_01 +00000000000003AD_446B4000_00 +FFFFFFFFFFF00000_5F800000_01 +FFFFFF0000100020_5F800000_01 +67F167FBC7FC5F9A_5ECFE2D0_01 +FFFFFFFFFFF80000_5F800000_01 +003FFFFFFFFC0001_5A800000_01 +002E48F9F4EBD30E_5A3923E8_01 +FFFFFFFFFFFC0000_5F800000_01 +DFFFFFFFFFFBFFFE_5F600000_01 +0091C23EE8C9424F_5B11C23F_01 +FFFFFFFFFFFE0000_5F800000_01 +F7DFFBFFFFFFFFFE_5F77DFFC_01 +00000000ACAE080C_4F2CAE09_01 +FFFFFFFFFFFF0000_5F800000_01 +FFFFC00010000020_5F7FFFC1_01 +0CD921F917B20E40_5D4D9220_01 +FFFFFFFFFFFF8000_5F800000_01 +F8000FFFFFFFFFFD_5F780010_01 +00017C566BC7D811_57BE2B36_01 +FFFFFFFFFFFFC000_5F800000_01 +00000000000000FE_437E0000_00 +00F82AC14930D386_5B782AC2_01 +FFFFFFFFFFFFE000_5F800000_01 +00000000000003FC_447F0000_00 +008E62EC60E119FC_5B0E62ED_01 +FFFFFFFFFFFFF000_5F800000_01 +FFFFEFF7FF7FFFFE_5F7FFFF0_01 +1E2B1ECF210EEDC5_5DF158F7_01 +FFFFFFFFFFFFF800_5F800000_01 +00000000007FFF1F_4AFFFE3E_00 +000006534F5676F7_54CA69EB_01 +FFFFFFFFFFFFFC00_5F800000_01 +0000001004FFFFFD_51802800_01 +0000435C939669F1_5686B928_01 +FFFFFFFFFFFFFE00_5F800000_01 +1FFFFFFFFFFFFDFD_5E000000_01 +0000000000000011_41880000_00 +FFFFFFFFFFFFFF00_5F800000_01 +01FFFFFFFBFFEFFE_5C000000_01 +000000000000036E_445B8000_00 +FFFFFFFFFFFFFF80_5F800000_01 +FFF7FFFFFFFFF7FD_5F7FF800_01 +000038E2BCFAC553_56638AF4_01 +FFFFFFFFFFFFFFC0_5F800000_01 +FFFFFBFFFFFE0FFE_5F7FFFFC_01 +00000009A4E704BF_511A4E71_01 +FFFFFFFFFFFFFFE0_5F800000_01 +1400007FFFFFFFFD_5DA00004_01 +0000000093B187B4_4F13B188_01 +FFFFFFFFFFFFFFF0_5F800000_01 +40000000007FFFFD_5E800001_01 +0000000000E7D468_4B67D468_00 +FFFFFFFFFFFFFFF8_5F800000_01 +007FFEFFFFFBFFFE_5AFFFE00_01 +000000026CEC79F8_501B3B1F_01 +FFFFFFFFFFFFFFFC_5F800000_01 +00FFFFFF000000FF_5B800000_01 +0000000000D3983A_4B53983A_00 +FFFFFFFFFFFFFFFE_5F800000_01 +00007FFFBFFF7FFE_56FFFF80_01 +00000001F4A7088A_4FFA5385_01 +FFFFFFFFFFFFFFFF_5F800000_01 +000008000000027E_55000001_01 +000000000001F4E8_47FA7400_00 +FFFFFFFFFFFFFFFD_5F800000_01 +FFFFFFFFFF83FFDF_5F800000_01 +00001E11407887B2_55F08A04_01 +FFFFFFFFFFFFFFFB_5F800000_01 +04000003FFFFFFF6_5C800001_01 +0000000000000D13_45513000_00 +FFFFFFFFFFFFFFF7_5F800000_01 +BFFC00000000003E_5F3FFC01_01 +00000028D7BBB75B_52235EEF_01 +FFFFFFFFFFFFFFEF_5F800000_01 +000FFFFBFFFC0000_597FFFC0_01 +0000000000CD5A23_4B4D5A23_00 +FFFFFFFFFFFFFFDF_5F800000_01 +FFBFDFFFBFFFFFFF_5F7FBFE0_01 +00000000000000FF_437F0000_00 +FFFFFFFFFFFFFFBF_5F800000_01 +00000007FF800003_50FFF001_01 +00000000000ABB02_492BB020_00 +FFFFFFFFFFFFFF7F_5F800000_01 +FFFFFFFFFFFEE7FF_5F800000_01 +00664B2B9BAD0DA2_5ACC9658_01 +FFFFFFFFFFFFFEFF_5F800000_01 +0000000000100803_49804018_00 +009B1DCB9F857D5E_5B1B1DCC_01 +FFFFFFFFFFFFFDFF_5F800000_01 +FFFFFFBFFFFFEFEE_5F800000_01 +36FD7542899C1C6F_5E5BF5D6_01 +FFFFFFFFFFFFFBFF_5F800000_01 +FF800000004001FF_5F7F8001_01 +0000000006BE4932_4CD7C927_01 +FFFFFFFFFFFFF7FF_5F800000_01 +00001004000FFFFE_55802001_01 +0000001DAA0123E0_51ED500A_01 +FFFFFFFFFFFFEFFF_5F800000_01 +00000001FDFFFDFE_4FFEFFFF_01 +00001C8703B1DCB0_55E4381E_01 +FFFFFFFFFFFFDFFF_5F800000_01 +FE0FE00000000000_5F7E0FE0_00 +0F79ED944A4E2779_5D779EDA_01 +FFFFFFFFFFFFBFFF_5F800000_01 +FBFFFE0400000000_5F7BFFFF_01 +0000030127E03666_544049F9_01 +FFFFFFFFFFFF7FFF_5F800000_01 +FFFFF0200000FFFE_5F7FFFF1_01 +000000000000017F_43BF8000_00 +FFFFFFFFFFFEFFFF_5F800000_01 +FFEFFE0000080000_5F7FEFFF_01 +00000000013354EA_4B99AA75_00 +FFFFFFFFFFFDFFFF_5F800000_01 +003FF0000003FFFE_5A7FC001_01 +0000016375B23F7B_53B1BADA_01 +FFFFFFFFFFFBFFFF_5F800000_01 +000407FFFFFFFFF6_58810000_01 +0000000192117F38_4FC908C0_01 +FFFFFFFFFFF7FFFF_5F800000_01 +FFFFFFFFFFFF7FFF_5F800000_01 +00000000000018BE_45C5F000_00 +FFFFFFFFFFEFFFFF_5F800000_01 +004000020FFFFFFF_5A800005_01 +0000B84C2D8BC9CB_57384C2E_01 +FFFFFFFFFFDFFFFF_5F800000_01 +00FFFFFFFFFFFFFD_5B800000_01 +00000223C2C6F284_5408F0B2_01 +FFFFFFFFFFBFFFFF_5F800000_01 +FFFDDFFFFFFFFFFD_5F7FFDE0_01 +00000000F46356C4_4F746357_01 +FFFFFFFFFF7FFFFF_5F800000_01 +010000000000BFFF_5B800001_01 +0000000000000005_40A00000_00 +FFFFFFFFFEFFFFFF_5F800000_01 +FFFFBF7FFBFFFFFE_5F7FFFC0_01 +00000026386CE889_5218E1B4_01 +FFFFFFFFFDFFFFFF_5F800000_01 +F00000F7FFFFFFFF_5F700001_01 +0001FC53090C46A4_57FE2985_01 +FFFFFFFFFBFFFFFF_5F800000_01 +0000000000800047_4B000047_00 +000000001693872E_4DB49C3A_01 +FFFFFFFFF7FFFFFF_5F800000_01 +000000007FBFFBFF_4EFF7FF8_01 +00000226A7845E35_5409A9E2_01 +FFFFFFFFEFFFFFFF_5F800000_01 +FFFFFFDFFFFFFBFD_5F800000_01 +000000005433D14C_4EA867A3_01 +FFFFFFFFDFFFFFFF_5F800000_01 +0001FFFFFFE0000E_58000000_01 +00F23E8068D3D84A_5B723E81_01 +FFFFFFFFBFFFFFFF_5F800000_01 +F7FFBFFFFFFFBFFF_5F77FFC0_01 +0000BD29B7459087_573D29B8_01 +FFFFFFFF7FFFFFFF_5F800000_01 +FFFFFFF8FFFFBFFF_5F800000_01 +00000000002DDC06_4A377018_00 +FFFFFFFEFFFFFFFF_5F800000_01 +FFFFFFF80001FFFF_5F800000_01 +0000000000012FF9_4797FC80_00 +FFFFFFFDFFFFFFFF_5F800000_01 +004000040000FFFF_5A800009_01 +0000000000000001_3F800000_00 +FFFFFFFBFFFFFFFF_5F800000_01 +C0000000007FFFFA_5F400001_01 +0000000006053E2B_4CC0A7C6_01 +FFFFFFF7FFFFFFFF_5F800000_01 +7FFE000007FFFFFF_5EFFFC01_01 +000000000000002D_42340000_00 +FFFFFFEFFFFFFFFF_5F800000_01 +F80000000001007E_5F780001_01 +00000D48424AD9D6_55548425_01 +FFFFFFDFFFFFFFFF_5F800000_01 +FFFFFE0001FEFFFF_5F7FFFFF_01 +000000000000033B_444EC000_00 +FFFFFFBFFFFFFFFF_5F800000_01 +0007FBFFFFFDFFFE_58FF8000_01 +4A16BD4128090C83_5E942D7B_01 +FFFFFF7FFFFFFFFF_5F800000_01 +00FFF7FFFF7FFFFE_5B7FF800_01 +0000000000000086_43060000_00 +FFFFFEFFFFFFFFFF_5F7FFFFF_01 +FBFFFFBFFFBFFFFF_5F7C0000_01 +00000000000021BA_4606E800_00 +FFFFFDFFFFFFFFFF_5F7FFFFE_01 +0000000040000082_4E800002_01 +0007A2BF5B689F89_58F457EC_01 +FFFFFBFFFFFFFFFF_5F7FFFFC_01 +0000001FF8000008_51FFC001_01 +387CAA7DE672DE8B_5E61F2AA_01 +FFFFF7FFFFFFFFFF_5F7FFFF8_01 +07FFF80000000002_5CFFFF01_01 +0000000030A1E5B8_4E428797_01 +FFFFEFFFFFFFFFFF_5F7FFFF0_01 +F7FFFFE00007FFFF_5F780000_01 +000000000006ADFC_48D5BF80_00 +FFFFDFFFFFFFFFFF_5F7FFFE0_01 +FFFFFF03FFFFFFC0_5F800000_01 +0A579475948F0032_5D257948_01 +FFFFBFFFFFFFFFFF_5F7FFFC0_01 +FC00000000003FF6_5F7C0001_01 +00AE677AC313BF60_5B2E677B_01 +FFFF7FFFFFFFFFFF_5F7FFF80_01 +02000007FF7FFFFF_5C000002_01 +0000002E999639F1_523A6659_01 +FFFEFFFFFFFFFFFF_5F7FFF00_01 +FFFF83FFFFFFFFBE_5F7FFF84_01 +000000000003537D_4854DF40_00 +FFFDFFFFFFFFFFFF_5F7FFE00_01 +EFFFFFC00000003D_5F700000_01 +000000121FEDFD35_5190FF70_01 +FFFBFFFFFFFFFFFF_5F7FFC00_01 +FFFFFFF0000007FE_5F800000_01 +00000000001E0839_49F041C8_00 +FFF7FFFFFFFFFFFF_5F7FF800_01 +0000007FFFE000FF_52FFFFC1_01 +0000000079F30F48_4EF3E61F_01 +FFEFFFFFFFFFFFFF_5F7FF000_01 +FFFFFC13FFFFFFFD_5F7FFFFD_01 +0000000000003B85_466E1400_00 +FFDFFFFFFFFFFFFF_5F7FE000_01 +000008000007FFFE_55000001_01 +32DB4409E5AE87E6_5E4B6D11_01 +FFBFFFFFFFFFFFFF_5F7FC000_01 +FFFFFFFFFFF7BFEE_5F800000_01 +000000000000003D_42740000_00 +FF7FFFFFFFFFFFFF_5F7F8000_01 +000000001040FFFE_4D820800_01 +00004909A09C13D3_56921342_01 +FEFFFFFFFFFFFFFF_5F7F0000_01 +FFFFFF01FFFFFF7F_5F800000_01 +00000072E7D2575D_52E5CFA5_01 +FDFFFFFFFFFFFFFF_5F7E0000_01 +FFFFFFFFFFFEFFDB_5F800000_01 +0000000000000057_42AE0000_00 +FBFFFFFFFFFFFFFF_5F7C0000_01 +100000001FFFFFF6_5D800001_01 +000000914B12EF51_53114B13_01 +F7FFFFFFFFFFFFFF_5F780000_01 +0407FFFFFFFFFEFF_5C810000_01 +000000769F3A5C2C_52ED3E75_01 +EFFFFFFFFFFFFFFF_5F700000_01 +FFFFFFFDF7FFFFFD_5F800000_01 +0000000000000002_40000000_00 +DFFFFFFFFFFFFFFF_5F600000_01 +FFFFFFFFFE0007FF_5F800000_01 +000000000000009E_431E0000_00 +BFFFFFFFFFFFFFFF_5F400000_01 +FFF800000009FFFF_5F7FF801_01 +0000000000087AA4_4907AA40_00 +7FFFFFFFFFFFFFFF_5F000000_01 +4080000000FFFFFF_5E810001_01 +000000001DE7601D_4DEF3B01_01 +3FFFFFFFFFFFFFFF_5E800000_01 +FFCFFFFFFFBFFFFE_5F7FD000_01 +000000000000004A_42940000_00 +1FFFFFFFFFFFFFFF_5E000000_01 +000080400000003F_57004001_01 +00000000003F75A5_4A7DD694_00 +0FFFFFFFFFFFFFFF_5D800000_01 +FFFFFFEFFFFFCFFE_5F800000_01 +000000E775887420_53677589_01 +07FFFFFFFFFFFFFF_5D000000_01 +00000000000801FE_49001FE0_00 +0000000000A13FF1_4B213FF1_00 +03FFFFFFFFFFFFFF_5C800000_01 +07FEFFFFFFFFFFEE_5CFFE000_01 +000000000000000C_41400000_00 +01FFFFFFFFFFFFFF_5C000000_01 +0000000820000003_51020001_01 +00000001AD105214_4FD6882A_01 +00FFFFFFFFFFFFFF_5B800000_01 +FFFFF00FFFFFFFBE_5F7FFFF1_01 +0000000000CC48E7_4B4C48E7_00 +007FFFFFFFFFFFFF_5B000000_01 +00000FFFEF7FFFFF_557FFEF8_01 +00000000000BA6CB_493A6CB0_00 +003FFFFFFFFFFFFF_5A800000_01 +FFFFFF7FBFFFFFBF_5F800000_01 +0000000000024425_48110940_00 +001FFFFFFFFFFFFF_5A000000_01 +200000001FFBFFFF_5E000001_01 +0000004E7115EC53_529CE22C_01 +000FFFFFFFFFFFFF_59800000_01 +FFFFF803FFFFFFBF_5F7FFFF9_01 +0000002E539ADCFE_52394E6C_01 +0007FFFFFFFFFFFF_59000000_01 +FFFFFFFFFBFFFFFF_5F800000_01 +000000D5084732F3_53550848_01 +0003FFFFFFFFFFFF_58800000_01 +BFFF7FFFFFFFFE00_5F3FFF80_01 +0000000000000543_44A86000_00 +0001FFFFFFFFFFFF_58000000_01 +0000001FFBFFE000_51FFDFFF_00 +000000000000491B_46923600_00 +0000FFFFFFFFFFFF_57800000_01 +FC00200000001FFE_5F7C0021_01 +0000016898822A24_53B44C42_01 +00007FFFFFFFFFFF_57000000_01 +3FFF03FFFFFFFFFE_5E7FFC10_01 +0000000FFE18C7BF_517FE18D_01 +00003FFFFFFFFFFF_56800000_01 +FFFFFEFFFEFFFFFD_5F7FFFFF_01 +02F03620C1266ED9_5C3C0D89_01 +00001FFFFFFFFFFF_56000000_01 +BF7EFFFFFFFFFFFF_5F3F7F00_01 +0000000000000055_42AA0000_00 +00000FFFFFFFFFFF_55800000_01 +FFFBFFFFF803FFFE_5F7FFC00_01 +0000000000168684_49B43420_00 +000007FFFFFFFFFF_55000000_01 +DFFFFFE00000001E_5F600000_01 +0000000000000CF5_454F5000_00 +000003FFFFFFFFFF_54800000_01 +FFFF00400000FFFF_5F7FFF01_01 +0000000000000022_42080000_00 +000001FFFFFFFFFF_54000000_01 +FBFFFFFFFFFFBDFE_5F7C0000_01 +0000000000001BC9_45DE4800_00 +000000FFFFFFFFFF_53800000_01 +807FFFFFFFFFDFFE_5F008000_01 +000274E35A70CD76_581D38D7_01 +0000007FFFFFFFFF_53000000_01 +0FFFFFFFFEFFFFFD_5D800000_01 +0000000300E73AFC_504039CF_01 +0000003FFFFFFFFF_52800000_01 +FFC000000001000E_5F7FC001_01 +00000000000615E9_48C2BD20_00 +0000001FFFFFFFFF_52000000_01 +0001FFFFFFFFF3FD_58000000_01 +00000000000000B3_43330000_00 +0000000FFFFFFFFF_51800000_01 +000000001FFFBFFF_4DFFFE00_01 +0000006E6B141E1B_52DCD629_01 +00000007FFFFFFFF_51000000_01 +FFFFFFFFF60007FF_5F800000_01 +00000003AB310BA6_506ACC43_01 +00000003FFFFFFFF_50800000_01 +0003FFFFB7FFFFFF_587FFFEE_01 +0000000000000195_43CA8000_00 +00000001FFFFFFFF_50000000_01 +FFFFFFFF8000000B_5F800000_01 +00000059BA8D5559_52B3751B_01 +00000000FFFFFFFF_4F800000_01 +FBFEFFFFFFFFFFF9_5F7BFF00_01 +000001B6F062822D_53DB7832_01 +000000007FFFFFFF_4F000000_01 +0001000000000082_57800001_01 +03CEAD9E2FB104A4_5C73AB68_01 +000000003FFFFFFF_4E800000_01 +000003FFFFFFFF7C_54800000_01 +000000000D681E78_4D5681E8_01 +000000001FFFFFFF_4E000000_01 +00002000400001FF_56000101_01 +0000000000000058_42B00000_00 +000000000FFFFFFF_4D800000_01 +3FFF80000000003E_5E7FFE01_01 +0000000000000095_43150000_00 +0000000007FFFFFF_4D000000_01 +010000BFFFFFFFFF_5B800060_01 +0000009697087B19_53169709_01 +0000000003FFFFFF_4C800000_01 +FBFFFFFFFFEEFFFD_5F7C0000_01 +0000001E64BDFC55_51F325F0_01 +0000000001FFFFFF_4C000000_01 +FC00000001FFFFFE_5F7C0001_01 +0000D156A62AB849_575156A7_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_5F800000_01 +00035354EAE7C259_5854D53B_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_5F800000_01 +00000000F4DF3C75_4F74DF3D_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_5F7FFA01_01 +0000000000000003_40400000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_5F800000_01 +0000005B5433CB9B_52B6A868_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_5F7FFFFE_01 +0000000000DEAE1F_4B5EAE1F_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_5F800000_01 +000000007735DEC7_4EEE6BBE_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFE0000_01 +000007757D8B12ED_54EEAFB2_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_5F7FFFFF_01 +00002A654064E046_56299502_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000001_01 +0000000000000007_40E00000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5D000000_01 +00002D78B3D6C3B6_5635E2D0_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +000000070B77F34F_50E16EFF_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_5F800000_01 +0000093EB4D67EC8_5513EB4E_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_5F3FFFE0_01 +0205CEAF34EA1DC7_5C0173AC_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900001_01 +0000000000000003_40400000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000760D0_48EC1A00_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B802000_01 +02C000708FF1BA51_5C30001D_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_5F780201_01 +4F9E07DCC0BDC061_5E9F3C10_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC001_01 +00000001B9B2A079_4FDCD951_01 +000000000000003F_427C0000_00 +FFF80000000080FF_5F7FF801_01 +00000000005EB5B4_4ABD6B68_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +0000000000DAC607_4B5AC607_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_5F800000_01 +00000DC5B9D66984_555C5B9E_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_5F400200_01 +00003D06B372AA06_56741ACE_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f32_rz.tv b/wally-pipelined/testbench/fp/ui64_f32_rz.tv new file mode 100644 index 000000000..bf85027ae --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f32_rz.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_5CFFFFBF_01 +0000000072CC8B7A_4EE59916_01 +0000000000000000_00000000_00 +FFFFFFFFC0003FFE_5F7FFFFF_01 +072C857F319EDE38_5CE590AF_01 +0000000000000001_3F800000_00 +FFFFFBFFFFF8003E_5F7FFFFB_01 +00794C79B6D3007B_5AF298F3_01 +0000000000000002_40000000_00 +FBFFFFF0000001FF_5F7BFFFF_01 +0000000005AE458D_4CB5C8B1_01 +0000000000000004_40800000_00 +00040008000007FE_58800100_01 +09EB456140D88764_5D1EB456_01 +0000000000000008_41000000_00 +FFFFE400FFFFFFFE_5F7FFFE4_01 +27DE834A248EDF36_5E1F7A0D_01 +0000000000000010_41800000_00 +00000003FF001FFF_507FC007_01 +00000000000385E2_48617880_00 +0000000000000020_42000000_00 +F0041FFFFFFFFFFF_5F70041F_01 +000000159EB1FD45_51ACF58F_01 +0000000000000040_42800000_00 +FFFFFFFFFFFCFFF9_5F7FFFFF_01 +000000000002DDFE_48377F80_00 +0000000000000080_43000000_00 +000000000003FF00_487FC000_00 +00000002C89FF56B_503227FD_01 +0000000000000100_43800000_00 +000FFFFF7FDFFFFF_597FFFF7_01 +3B5E4F0BE0DEBFF0_5E6D793C_01 +0000000000000200_44000000_00 +FFFDF803FFFFFFFF_5F7FFDF8_01 +000000000004766B_488ECD60_00 +0000000000000400_44800000_00 +0000080100000FFE_55001000_01 +000000000000002C_42300000_00 +0000000000000800_45000000_00 +0048000000100000_5A900000_01 +07E662A109109D0A_5CFCCC54_01 +0000000000001000_45800000_00 +C000000037FFFFFE_5F400000_01 +0000000000000064_42C80000_00 +0000000000002000_46000000_00 +F801000000100000_5F780100_01 +02114B79075F70EE_5C0452DE_01 +0000000000004000_46800000_00 +100000000001003E_5D800000_01 +0000000000000BAC_453AC000_00 +0000000000008000_47000000_00 +200000FFFFFFF800_5E000003_01 +000000C4A3A3DBE5_5344A3A3_01 +0000000000010000_47800000_00 +FFE0003EFFFFFFFF_5F7FE000_01 +0000000000001A91_45D48800_00 +0000000000020000_48000000_00 +FFFFF7C3FFFFFFFD_5F7FFFF7_01 +0000000000007309_46E61200_00 +0000000000040000_48800000_00 +000083FFF7FFFFFE_5703FFF7_01 +0000000000000F58_45758000_00 +0000000000080000_49000000_00 +FFFFFFDE01FFFFFE_5F7FFFFF_01 +0000000000006980_46D30000_00 +0000000000100000_49800000_00 +00000000FFF07FFF_4F7FF07F_01 +00000000000000DD_435D0000_00 +0000000000200000_4A000000_00 +000020FFDFFFFFFF_5603FF7F_01 +00008C23DA2CEAD8_570C23DA_01 +0000000000400000_4A800000_00 +E0000000003FFFDF_5F600000_01 +00000DE3C1DEC43C_555E3C1D_01 +0000000000800000_4B000000_00 +FFFF00000BFFFFFD_5F7FFF00_01 +000000008030FFBE_4F0030FF_01 +0000000001000000_4B800000_00 +FFFE000007FFEFFD_5F7FFE00_01 +000000000FDEED86_4D7DEED8_01 +0000000002000000_4C000000_00 +F3FFFFFFFFBFFFFE_5F73FFFF_01 +000000005DA3FF45_4EBB47FE_01 +0000000004000000_4C800000_00 +FFFFFFFF00010007_5F7FFFFF_01 +000000009B1BCB54_4F1B1BCB_01 +0000000008000000_4D000000_00 +00004000004001FE_56800000_01 +027DD19DE6563714_5C1F7467_01 +0000000010000000_4D800000_00 +FFC00000004007FE_5F7FC000_01 +000000000003A359_4868D640_00 +0000000020000000_4E000000_00 +0000000003C000FE_4C70003F_01 +000000003E62EC20_4E798BB0_01 +0000000040000000_4E800000_00 +000000003FFFFFFD_4E7FFFFF_01 +000000000000685F_46D0BE00_00 +0000000080000000_4F000000_00 +FFFFFFFFBFFFF00F_5F7FFFFF_01 +00000836F99DBAA8_55036F99_01 +0000000100000000_4F800000_00 +00000020003FFEFE_520000FF_01 +0073466832042D47_5AE68CD0_01 +0000000200000000_50000000_00 +FFFFFFFFFFFFF887_5F7FFFFF_01 +00000000007829C8_4AF05390_00 +0000000400000000_50800000_00 +00000FFFFFFF7DFD_557FFFFF_01 +0000001FB77C672B_51FDBBE3_01 +0000000800000000_51000000_00 +08003FFDFFFFFFFE_5D0003FF_01 +0000000000005B78_46B6F000_00 +0000001000000000_51800000_00 +FF7FFFFFFFEFDFFF_5F7F7FFF_01 +00000000000000F1_43710000_00 +0000002000000000_52000000_00 +000013FFFFFFFDFF_559FFFFF_01 +0000000000000006_40C00000_00 +0000004000000000_52800000_00 +0800000000040800_5D000000_01 +0008A60D9E19F17E_590A60D9_01 +0000008000000000_53000000_00 +000077FFF0000000_56EFFFE0_00 +0000000007506DBA_4CEA0DB7_01 +0000010000000000_53800000_00 +FFFFFFFFFFFEFBF7_5F7FFFFF_01 +0000000006A42AC9_4CD48559_01 +0000020000000000_54000000_00 +0000107FFFFFDFFD_5583FFFF_01 +0007AA3F2BDACC89_58F547E5_01 +0000040000000000_54800000_00 +FFF8040000040000_5F7FF804_01 +0000000000000005_40A00000_00 +0000080000000000_55000000_00 +FFFF80000800001F_5F7FFF80_01 +000DF681DECDADC9_595F681D_01 +0000100000000000_55800000_00 +FFFFFEFFFFE0007F_5F7FFFFE_01 +0000000000004FBE_469F7C00_00 +0000200000000000_56000000_00 +0000000901FFFFFD_51101FFF_01 +00C01FECA24DE1B0_5B401FEC_01 +0000400000000000_56800000_00 +F7FFFFFFDFFF7FFF_5F77FFFF_01 +0058A66761669936_5AB14CCE_01 +0000800000000000_57000000_00 +FFFEFF800000003E_5F7FFEFF_01 +0716EA43FAC45C97_5CE2DD48_01 +0001000000000000_57800000_00 +FFFFFFFFFFFFFFC6_5F7FFFFF_01 +0064D70EC7661FD8_5AC9AE1D_01 +0002000000000000_58000000_00 +C07FFFFFFFFFFFFE_5F407FFF_01 +00D956DBD0AEE817_5B5956DB_01 +0004000000000000_58800000_00 +020003EFFFFFFFFE_5C0000FB_01 +0000000000004300_46860000_00 +0008000000000000_59000000_00 +4000000004002000_5E800000_01 +012EDF40F41F6021_5B976FA0_01 +0010000000000000_59800000_00 +FF9000000000001D_5F7F9000_01 +000000383DE950F6_5260F7A5_01 +0020000000000000_5A000000_00 +800003FFFFFC0000_5F000003_01 +002B59CB3A604D69_5A2D672C_01 +0040000000000000_5A800000_00 +7FFFFFFDFFFFBFFF_5EFFFFFF_01 +000001A37C210862_53D1BE10_01 +0080000000000000_5B000000_00 +0002000002000002_58000000_01 +0000365CD8617789_56597361_01 +0100000000000000_5B800000_00 +00001BFFFFFFBFFE_55DFFFFF_01 +000000000000101D_4580E800_00 +0200000000000000_5C000000_00 +1000008000003FFF_5D800004_01 +000000001D098D19_4DE84C68_01 +0400000000000000_5C800000_00 +03FFFFFFFFFFF5FF_5C7FFFFF_01 +000016B3BD2C7BEF_55B59DE9_01 +0800000000000000_5D000000_00 +00003FFFBFFFFFFE_567FFEFF_01 +00004E5ADDDAA4A8_569CB5BB_01 +1000000000000000_5D800000_00 +001FFFC000000FFD_59FFFE00_01 +0000000000000721_44E42000_00 +2000000000000000_5E000000_00 +0000000041DFFFFF_4E83BFFF_01 +0000000000648262_4AC904C4_00 +4000000000000000_5E800000_00 +C0001FFFFFFFFFFB_5F40001F_01 +0000007353AC45D2_52E6A758_01 +8000000000000000_5F000000_00 +FFFFFFFFFFE7EFFF_5F7FFFFF_01 +0000000001A1202D_4BD09016_01 +C000000000000000_5F400000_00 +FFFFFFFFFFFF5F7F_5F7FFFFF_01 +0000000000C0CA70_4B40CA70_00 +E000000000000000_5F600000_00 +0000200201FFFFFE_56000807_01 +00000007B55D87D4_50F6ABB0_01 +F000000000000000_5F700000_00 +FF80000DFFFFFFFF_5F7F8000_01 +000000090510FAEF_5110510F_01 +F800000000000000_5F780000_00 +0003FFF00000000F_587FFC00_01 +000000000001724A_47B92500_00 +FC00000000000000_5F7C0000_00 +FFFFFFDF80000002_5F7FFFFF_01 +00000000000000E4_43640000_00 +FE00000000000000_5F7E0000_00 +FEFFFFFFFFF800FE_5F7EFFFF_01 +00000002C6222702_50318889_01 +FF00000000000000_5F7F0000_00 +0000000408000002_50810000_01 +000002E96DF1CB41_543A5B7C_01 +FF80000000000000_5F7F8000_00 +007FFFFFFFFFF9FE_5AFFFFFF_01 +0727F174DEE7DC85_5CE4FE2E_01 +FFC0000000000000_5F7FC000_00 +8000000003FFFEFE_5F000000_01 +000000000010BD5B_4985EAD8_00 +FFE0000000000000_5F7FE000_00 +0BEFFFFFFFFFFFFF_5D3EFFFF_01 +000000000022790C_4A09E430_00 +FFF0000000000000_5F7FF000_00 +FFFFFFFFFFEFFBFA_5F7FFFFF_01 +000000369E75DF01_525A79D7_01 +FFF8000000000000_5F7FF800_00 +00000007FEFFDFFF_50FFDFFB_01 +000000000000001E_41F00000_00 +FFFC000000000000_5F7FFC00_00 +0003FFFE0007FFFE_587FFF80_01 +0000000000328622_4A4A1888_00 +FFFE000000000000_5F7FFE00_00 +FFFFFF7FFFFDF7FF_5F7FFFFF_01 +00172F0EC496FE21_59B97876_01 +FFFF000000000000_5F7FFF00_00 +DFBFFFFFFFFFFFFE_5F5FBFFF_01 +0000000004FC1FCA_4C9F83F9_01 +FFFF800000000000_5F7FFF80_00 +00000FFF800FFFFE_557FF800_01 +000F5194E4A9C2CE_5975194E_01 +FFFFC00000000000_5F7FFFC0_00 +00000002100007FD_50040001_01 +000000000002D8FE_48363F80_00 +FFFFE00000000000_5F7FFFE0_00 +000000000007FF6E_48FFEDC0_00 +000000000003766E_485D9B80_00 +FFFFF00000000000_5F7FFFF0_00 +0040000400000002_5A800008_01 +000000000000F841_47784100_00 +FFFFF80000000000_5F7FFFF8_00 +3DFFFFFFFFFFFF7E_5E77FFFF_01 +0000000549E17E30_50A93C2F_01 +FFFFFC0000000000_5F7FFFFC_00 +FFFFFFFFFFFFFEE1_5F7FFFFF_01 +0000000000000027_421C0000_00 +FFFFFE0000000000_5F7FFFFE_00 +000000000EFFFFDF_4D6FFFFD_01 +0000000000000373_445CC000_00 +FFFFFF0000000000_5F7FFFFF_00 +FD00000008000000_5F7D0000_01 +000000000005DBB1_48BB7620_00 +FFFFFF8000000000_5F7FFFFF_01 +FFFFFFFFFFF8007F_5F7FFFFF_01 +00000002FD10A515_503F4429_01 +FFFFFFC000000000_5F7FFFFF_01 +FFEFFFFFFFFFFFFE_5F7FEFFF_01 +0AB02984F6283B6C_5D2B0298_01 +FFFFFFE000000000_5F7FFFFF_01 +FFFFFFBC000001FE_5F7FFFFF_01 +00B087C6B9FE7FE0_5B3087C6_01 +FFFFFFF000000000_5F7FFFFF_01 +FFF80001000007FE_5F7FF800_01 +01F2762EA6837956_5BF93B17_01 +FFFFFFF800000000_5F7FFFFF_01 +FFF7E0FFFFFFFFFE_5F7FF7E0_01 +00022E1175484626_580B845D_01 +FFFFFFFC00000000_5F7FFFFF_01 +0000200020000FFE_56000080_01 +000000000000168F_45B47800_00 +FFFFFFFE00000000_5F7FFFFF_01 +021FFFFFFFFBFFFF_5C07FFFF_01 +0000000000000001_3F800000_00 +FFFFFFFF00000000_5F7FFFFF_01 +FFFFFFD0000FFFFD_5F7FFFFF_01 +000001BDF6658B83_53DEFB32_01 +FFFFFFFF80000000_5F7FFFFF_01 +1000001FFDFFFFFF_5D800000_01 +000000000000BB5B_473B5B00_00 +FFFFFFFFC0000000_5F7FFFFF_01 +FFFFFFBFFE0FFFFF_5F7FFFFF_01 +0000000000000000_00000000_00 +FFFFFFFFE0000000_5F7FFFFF_01 +FFFFFFFBF00007FF_5F7FFFFF_01 +01E986274F48EAAD_5BF4C313_01 +FFFFFFFFF0000000_5F7FFFFF_01 +1FFFFFFDFFFFFF7F_5DFFFFFF_01 +000000000000CB5A_474B5A00_00 +FFFFFFFFF8000000_5F7FFFFF_01 +7FF000000000FFFF_5EFFE000_01 +0000000BC2717FC3_513C2717_01 +FFFFFFFFFC000000_5F7FFFFF_01 +FFFFFFE00008001F_5F7FFFFF_01 +00000000000FABDA_497ABDA0_00 +FFFFFFFFFE000000_5F7FFFFF_01 +0200000000000002_5C000000_01 +0000000000FDA53F_4B7DA53F_00 +FFFFFFFFFF000000_5F7FFFFF_01 +F6000003FFFFFFFE_5F760000_01 +0000000000000010_41800000_00 +FFFFFFFFFF800000_5F7FFFFF_01 +FFFFFFFFFFBFFF7E_5F7FFFFF_01 +00000001EE0FEA62_4FF707F5_01 +FFFFFFFFFFC00000_5F7FFFFF_01 +0000007FFF9FFFFD_52FFFF3F_01 +00000077F35EDC1D_52EFE6BD_01 +FFFFFFFFFFE00000_5F7FFFFF_01 +FFFFFFF7FDFFFF7D_5F7FFFFF_01 +00000000000003AD_446B4000_00 +FFFFFFFFFFF00000_5F7FFFFF_01 +FFFFFF0000100020_5F7FFFFF_01 +67F167FBC7FC5F9A_5ECFE2CF_01 +FFFFFFFFFFF80000_5F7FFFFF_01 +003FFFFFFFFC0001_5A7FFFFF_01 +002E48F9F4EBD30E_5A3923E7_01 +FFFFFFFFFFFC0000_5F7FFFFF_01 +DFFFFFFFFFFBFFFE_5F5FFFFF_01 +0091C23EE8C9424F_5B11C23E_01 +FFFFFFFFFFFE0000_5F7FFFFF_01 +F7DFFBFFFFFFFFFE_5F77DFFB_01 +00000000ACAE080C_4F2CAE08_01 +FFFFFFFFFFFF0000_5F7FFFFF_01 +FFFFC00010000020_5F7FFFC0_01 +0CD921F917B20E40_5D4D921F_01 +FFFFFFFFFFFF8000_5F7FFFFF_01 +F8000FFFFFFFFFFD_5F78000F_01 +00017C566BC7D811_57BE2B35_01 +FFFFFFFFFFFFC000_5F7FFFFF_01 +00000000000000FE_437E0000_00 +00F82AC14930D386_5B782AC1_01 +FFFFFFFFFFFFE000_5F7FFFFF_01 +00000000000003FC_447F0000_00 +008E62EC60E119FC_5B0E62EC_01 +FFFFFFFFFFFFF000_5F7FFFFF_01 +FFFFEFF7FF7FFFFE_5F7FFFEF_01 +1E2B1ECF210EEDC5_5DF158F6_01 +FFFFFFFFFFFFF800_5F7FFFFF_01 +00000000007FFF1F_4AFFFE3E_00 +000006534F5676F7_54CA69EA_01 +FFFFFFFFFFFFFC00_5F7FFFFF_01 +0000001004FFFFFD_518027FF_01 +0000435C939669F1_5686B927_01 +FFFFFFFFFFFFFE00_5F7FFFFF_01 +1FFFFFFFFFFFFDFD_5DFFFFFF_01 +0000000000000011_41880000_00 +FFFFFFFFFFFFFF00_5F7FFFFF_01 +01FFFFFFFBFFEFFE_5BFFFFFF_01 +000000000000036E_445B8000_00 +FFFFFFFFFFFFFF80_5F7FFFFF_01 +FFF7FFFFFFFFF7FD_5F7FF7FF_01 +000038E2BCFAC553_56638AF3_01 +FFFFFFFFFFFFFFC0_5F7FFFFF_01 +FFFFFBFFFFFE0FFE_5F7FFFFB_01 +00000009A4E704BF_511A4E70_01 +FFFFFFFFFFFFFFE0_5F7FFFFF_01 +1400007FFFFFFFFD_5DA00003_01 +0000000093B187B4_4F13B187_01 +FFFFFFFFFFFFFFF0_5F7FFFFF_01 +40000000007FFFFD_5E800000_01 +0000000000E7D468_4B67D468_00 +FFFFFFFFFFFFFFF8_5F7FFFFF_01 +007FFEFFFFFBFFFE_5AFFFDFF_01 +000000026CEC79F8_501B3B1E_01 +FFFFFFFFFFFFFFFC_5F7FFFFF_01 +00FFFFFF000000FF_5B7FFFFF_01 +0000000000D3983A_4B53983A_00 +FFFFFFFFFFFFFFFE_5F7FFFFF_01 +00007FFFBFFF7FFE_56FFFF7F_01 +00000001F4A7088A_4FFA5384_01 +FFFFFFFFFFFFFFFF_5F7FFFFF_01 +000008000000027E_55000000_01 +000000000001F4E8_47FA7400_00 +FFFFFFFFFFFFFFFD_5F7FFFFF_01 +FFFFFFFFFF83FFDF_5F7FFFFF_01 +00001E11407887B2_55F08A03_01 +FFFFFFFFFFFFFFFB_5F7FFFFF_01 +04000003FFFFFFF6_5C800000_01 +0000000000000D13_45513000_00 +FFFFFFFFFFFFFFF7_5F7FFFFF_01 +BFFC00000000003E_5F3FFC00_01 +00000028D7BBB75B_52235EEE_01 +FFFFFFFFFFFFFFEF_5F7FFFFF_01 +000FFFFBFFFC0000_597FFFBF_01 +0000000000CD5A23_4B4D5A23_00 +FFFFFFFFFFFFFFDF_5F7FFFFF_01 +FFBFDFFFBFFFFFFF_5F7FBFDF_01 +00000000000000FF_437F0000_00 +FFFFFFFFFFFFFFBF_5F7FFFFF_01 +00000007FF800003_50FFF000_01 +00000000000ABB02_492BB020_00 +FFFFFFFFFFFFFF7F_5F7FFFFF_01 +FFFFFFFFFFFEE7FF_5F7FFFFF_01 +00664B2B9BAD0DA2_5ACC9657_01 +FFFFFFFFFFFFFEFF_5F7FFFFF_01 +0000000000100803_49804018_00 +009B1DCB9F857D5E_5B1B1DCB_01 +FFFFFFFFFFFFFDFF_5F7FFFFF_01 +FFFFFFBFFFFFEFEE_5F7FFFFF_01 +36FD7542899C1C6F_5E5BF5D5_01 +FFFFFFFFFFFFFBFF_5F7FFFFF_01 +FF800000004001FF_5F7F8000_01 +0000000006BE4932_4CD7C926_01 +FFFFFFFFFFFFF7FF_5F7FFFFF_01 +00001004000FFFFE_55802000_01 +0000001DAA0123E0_51ED5009_01 +FFFFFFFFFFFFEFFF_5F7FFFFF_01 +00000001FDFFFDFE_4FFEFFFE_01 +00001C8703B1DCB0_55E4381D_01 +FFFFFFFFFFFFDFFF_5F7FFFFF_01 +FE0FE00000000000_5F7E0FE0_00 +0F79ED944A4E2779_5D779ED9_01 +FFFFFFFFFFFFBFFF_5F7FFFFF_01 +FBFFFE0400000000_5F7BFFFE_01 +0000030127E03666_544049F8_01 +FFFFFFFFFFFF7FFF_5F7FFFFF_01 +FFFFF0200000FFFE_5F7FFFF0_01 +000000000000017F_43BF8000_00 +FFFFFFFFFFFEFFFF_5F7FFFFF_01 +FFEFFE0000080000_5F7FEFFE_01 +00000000013354EA_4B99AA75_00 +FFFFFFFFFFFDFFFF_5F7FFFFF_01 +003FF0000003FFFE_5A7FC000_01 +0000016375B23F7B_53B1BAD9_01 +FFFFFFFFFFFBFFFF_5F7FFFFF_01 +000407FFFFFFFFF6_5880FFFF_01 +0000000192117F38_4FC908BF_01 +FFFFFFFFFFF7FFFF_5F7FFFFF_01 +FFFFFFFFFFFF7FFF_5F7FFFFF_01 +00000000000018BE_45C5F000_00 +FFFFFFFFFFEFFFFF_5F7FFFFF_01 +004000020FFFFFFF_5A800004_01 +0000B84C2D8BC9CB_57384C2D_01 +FFFFFFFFFFDFFFFF_5F7FFFFF_01 +00FFFFFFFFFFFFFD_5B7FFFFF_01 +00000223C2C6F284_5408F0B1_01 +FFFFFFFFFFBFFFFF_5F7FFFFF_01 +FFFDDFFFFFFFFFFD_5F7FFDDF_01 +00000000F46356C4_4F746356_01 +FFFFFFFFFF7FFFFF_5F7FFFFF_01 +010000000000BFFF_5B800000_01 +0000000000000005_40A00000_00 +FFFFFFFFFEFFFFFF_5F7FFFFF_01 +FFFFBF7FFBFFFFFE_5F7FFFBF_01 +00000026386CE889_5218E1B3_01 +FFFFFFFFFDFFFFFF_5F7FFFFF_01 +F00000F7FFFFFFFF_5F700000_01 +0001FC53090C46A4_57FE2984_01 +FFFFFFFFFBFFFFFF_5F7FFFFF_01 +0000000000800047_4B000047_00 +000000001693872E_4DB49C39_01 +FFFFFFFFF7FFFFFF_5F7FFFFF_01 +000000007FBFFBFF_4EFF7FF7_01 +00000226A7845E35_5409A9E1_01 +FFFFFFFFEFFFFFFF_5F7FFFFF_01 +FFFFFFDFFFFFFBFD_5F7FFFFF_01 +000000005433D14C_4EA867A2_01 +FFFFFFFFDFFFFFFF_5F7FFFFF_01 +0001FFFFFFE0000E_57FFFFFF_01 +00F23E8068D3D84A_5B723E80_01 +FFFFFFFFBFFFFFFF_5F7FFFFF_01 +F7FFBFFFFFFFBFFF_5F77FFBF_01 +0000BD29B7459087_573D29B7_01 +FFFFFFFF7FFFFFFF_5F7FFFFF_01 +FFFFFFF8FFFFBFFF_5F7FFFFF_01 +00000000002DDC06_4A377018_00 +FFFFFFFEFFFFFFFF_5F7FFFFF_01 +FFFFFFF80001FFFF_5F7FFFFF_01 +0000000000012FF9_4797FC80_00 +FFFFFFFDFFFFFFFF_5F7FFFFF_01 +004000040000FFFF_5A800008_01 +0000000000000001_3F800000_00 +FFFFFFFBFFFFFFFF_5F7FFFFF_01 +C0000000007FFFFA_5F400000_01 +0000000006053E2B_4CC0A7C5_01 +FFFFFFF7FFFFFFFF_5F7FFFFF_01 +7FFE000007FFFFFF_5EFFFC00_01 +000000000000002D_42340000_00 +FFFFFFEFFFFFFFFF_5F7FFFFF_01 +F80000000001007E_5F780000_01 +00000D48424AD9D6_55548424_01 +FFFFFFDFFFFFFFFF_5F7FFFFF_01 +FFFFFE0001FEFFFF_5F7FFFFE_01 +000000000000033B_444EC000_00 +FFFFFFBFFFFFFFFF_5F7FFFFF_01 +0007FBFFFFFDFFFE_58FF7FFF_01 +4A16BD4128090C83_5E942D7A_01 +FFFFFF7FFFFFFFFF_5F7FFFFF_01 +00FFF7FFFF7FFFFE_5B7FF7FF_01 +0000000000000086_43060000_00 +FFFFFEFFFFFFFFFF_5F7FFFFE_01 +FBFFFFBFFFBFFFFF_5F7BFFFF_01 +00000000000021BA_4606E800_00 +FFFFFDFFFFFFFFFF_5F7FFFFD_01 +0000000040000082_4E800001_01 +0007A2BF5B689F89_58F457EB_01 +FFFFFBFFFFFFFFFF_5F7FFFFB_01 +0000001FF8000008_51FFC000_01 +387CAA7DE672DE8B_5E61F2A9_01 +FFFFF7FFFFFFFFFF_5F7FFFF7_01 +07FFF80000000002_5CFFFF00_01 +0000000030A1E5B8_4E428796_01 +FFFFEFFFFFFFFFFF_5F7FFFEF_01 +F7FFFFE00007FFFF_5F77FFFF_01 +000000000006ADFC_48D5BF80_00 +FFFFDFFFFFFFFFFF_5F7FFFDF_01 +FFFFFF03FFFFFFC0_5F7FFFFF_01 +0A579475948F0032_5D257947_01 +FFFFBFFFFFFFFFFF_5F7FFFBF_01 +FC00000000003FF6_5F7C0000_01 +00AE677AC313BF60_5B2E677A_01 +FFFF7FFFFFFFFFFF_5F7FFF7F_01 +02000007FF7FFFFF_5C000001_01 +0000002E999639F1_523A6658_01 +FFFEFFFFFFFFFFFF_5F7FFEFF_01 +FFFF83FFFFFFFFBE_5F7FFF83_01 +000000000003537D_4854DF40_00 +FFFDFFFFFFFFFFFF_5F7FFDFF_01 +EFFFFFC00000003D_5F6FFFFF_01 +000000121FEDFD35_5190FF6F_01 +FFFBFFFFFFFFFFFF_5F7FFBFF_01 +FFFFFFF0000007FE_5F7FFFFF_01 +00000000001E0839_49F041C8_00 +FFF7FFFFFFFFFFFF_5F7FF7FF_01 +0000007FFFE000FF_52FFFFC0_01 +0000000079F30F48_4EF3E61E_01 +FFEFFFFFFFFFFFFF_5F7FEFFF_01 +FFFFFC13FFFFFFFD_5F7FFFFC_01 +0000000000003B85_466E1400_00 +FFDFFFFFFFFFFFFF_5F7FDFFF_01 +000008000007FFFE_55000000_01 +32DB4409E5AE87E6_5E4B6D10_01 +FFBFFFFFFFFFFFFF_5F7FBFFF_01 +FFFFFFFFFFF7BFEE_5F7FFFFF_01 +000000000000003D_42740000_00 +FF7FFFFFFFFFFFFF_5F7F7FFF_01 +000000001040FFFE_4D8207FF_01 +00004909A09C13D3_56921341_01 +FEFFFFFFFFFFFFFF_5F7EFFFF_01 +FFFFFF01FFFFFF7F_5F7FFFFF_01 +00000072E7D2575D_52E5CFA4_01 +FDFFFFFFFFFFFFFF_5F7DFFFF_01 +FFFFFFFFFFFEFFDB_5F7FFFFF_01 +0000000000000057_42AE0000_00 +FBFFFFFFFFFFFFFF_5F7BFFFF_01 +100000001FFFFFF6_5D800000_01 +000000914B12EF51_53114B12_01 +F7FFFFFFFFFFFFFF_5F77FFFF_01 +0407FFFFFFFFFEFF_5C80FFFF_01 +000000769F3A5C2C_52ED3E74_01 +EFFFFFFFFFFFFFFF_5F6FFFFF_01 +FFFFFFFDF7FFFFFD_5F7FFFFF_01 +0000000000000002_40000000_00 +DFFFFFFFFFFFFFFF_5F5FFFFF_01 +FFFFFFFFFE0007FF_5F7FFFFF_01 +000000000000009E_431E0000_00 +BFFFFFFFFFFFFFFF_5F3FFFFF_01 +FFF800000009FFFF_5F7FF800_01 +0000000000087AA4_4907AA40_00 +7FFFFFFFFFFFFFFF_5EFFFFFF_01 +4080000000FFFFFF_5E810000_01 +000000001DE7601D_4DEF3B00_01 +3FFFFFFFFFFFFFFF_5E7FFFFF_01 +FFCFFFFFFFBFFFFE_5F7FCFFF_01 +000000000000004A_42940000_00 +1FFFFFFFFFFFFFFF_5DFFFFFF_01 +000080400000003F_57004000_01 +00000000003F75A5_4A7DD694_00 +0FFFFFFFFFFFFFFF_5D7FFFFF_01 +FFFFFFEFFFFFCFFE_5F7FFFFF_01 +000000E775887420_53677588_01 +07FFFFFFFFFFFFFF_5CFFFFFF_01 +00000000000801FE_49001FE0_00 +0000000000A13FF1_4B213FF1_00 +03FFFFFFFFFFFFFF_5C7FFFFF_01 +07FEFFFFFFFFFFEE_5CFFDFFF_01 +000000000000000C_41400000_00 +01FFFFFFFFFFFFFF_5BFFFFFF_01 +0000000820000003_51020000_01 +00000001AD105214_4FD68829_01 +00FFFFFFFFFFFFFF_5B7FFFFF_01 +FFFFF00FFFFFFFBE_5F7FFFF0_01 +0000000000CC48E7_4B4C48E7_00 +007FFFFFFFFFFFFF_5AFFFFFF_01 +00000FFFEF7FFFFF_557FFEF7_01 +00000000000BA6CB_493A6CB0_00 +003FFFFFFFFFFFFF_5A7FFFFF_01 +FFFFFF7FBFFFFFBF_5F7FFFFF_01 +0000000000024425_48110940_00 +001FFFFFFFFFFFFF_59FFFFFF_01 +200000001FFBFFFF_5E000000_01 +0000004E7115EC53_529CE22B_01 +000FFFFFFFFFFFFF_597FFFFF_01 +FFFFF803FFFFFFBF_5F7FFFF8_01 +0000002E539ADCFE_52394E6B_01 +0007FFFFFFFFFFFF_58FFFFFF_01 +FFFFFFFFFBFFFFFF_5F7FFFFF_01 +000000D5084732F3_53550847_01 +0003FFFFFFFFFFFF_587FFFFF_01 +BFFF7FFFFFFFFE00_5F3FFF7F_01 +0000000000000543_44A86000_00 +0001FFFFFFFFFFFF_57FFFFFF_01 +0000001FFBFFE000_51FFDFFF_00 +000000000000491B_46923600_00 +0000FFFFFFFFFFFF_577FFFFF_01 +FC00200000001FFE_5F7C0020_01 +0000016898822A24_53B44C41_01 +00007FFFFFFFFFFF_56FFFFFF_01 +3FFF03FFFFFFFFFE_5E7FFC0F_01 +0000000FFE18C7BF_517FE18C_01 +00003FFFFFFFFFFF_567FFFFF_01 +FFFFFEFFFEFFFFFD_5F7FFFFE_01 +02F03620C1266ED9_5C3C0D88_01 +00001FFFFFFFFFFF_55FFFFFF_01 +BF7EFFFFFFFFFFFF_5F3F7EFF_01 +0000000000000055_42AA0000_00 +00000FFFFFFFFFFF_557FFFFF_01 +FFFBFFFFF803FFFE_5F7FFBFF_01 +0000000000168684_49B43420_00 +000007FFFFFFFFFF_54FFFFFF_01 +DFFFFFE00000001E_5F5FFFFF_01 +0000000000000CF5_454F5000_00 +000003FFFFFFFFFF_547FFFFF_01 +FFFF00400000FFFF_5F7FFF00_01 +0000000000000022_42080000_00 +000001FFFFFFFFFF_53FFFFFF_01 +FBFFFFFFFFFFBDFE_5F7BFFFF_01 +0000000000001BC9_45DE4800_00 +000000FFFFFFFFFF_537FFFFF_01 +807FFFFFFFFFDFFE_5F007FFF_01 +000274E35A70CD76_581D38D6_01 +0000007FFFFFFFFF_52FFFFFF_01 +0FFFFFFFFEFFFFFD_5D7FFFFF_01 +0000000300E73AFC_504039CE_01 +0000003FFFFFFFFF_527FFFFF_01 +FFC000000001000E_5F7FC000_01 +00000000000615E9_48C2BD20_00 +0000001FFFFFFFFF_51FFFFFF_01 +0001FFFFFFFFF3FD_57FFFFFF_01 +00000000000000B3_43330000_00 +0000000FFFFFFFFF_517FFFFF_01 +000000001FFFBFFF_4DFFFDFF_01 +0000006E6B141E1B_52DCD628_01 +00000007FFFFFFFF_50FFFFFF_01 +FFFFFFFFF60007FF_5F7FFFFF_01 +00000003AB310BA6_506ACC42_01 +00000003FFFFFFFF_507FFFFF_01 +0003FFFFB7FFFFFF_587FFFED_01 +0000000000000195_43CA8000_00 +00000001FFFFFFFF_4FFFFFFF_01 +FFFFFFFF8000000B_5F7FFFFF_01 +00000059BA8D5559_52B3751A_01 +00000000FFFFFFFF_4F7FFFFF_01 +FBFEFFFFFFFFFFF9_5F7BFEFF_01 +000001B6F062822D_53DB7831_01 +000000007FFFFFFF_4EFFFFFF_01 +0001000000000082_57800000_01 +03CEAD9E2FB104A4_5C73AB67_01 +000000003FFFFFFF_4E7FFFFF_01 +000003FFFFFFFF7C_547FFFFF_01 +000000000D681E78_4D5681E7_01 +000000001FFFFFFF_4DFFFFFF_01 +00002000400001FF_56000100_01 +0000000000000058_42B00000_00 +000000000FFFFFFF_4D7FFFFF_01 +3FFF80000000003E_5E7FFE00_01 +0000000000000095_43150000_00 +0000000007FFFFFF_4CFFFFFF_01 +010000BFFFFFFFFF_5B80005F_01 +0000009697087B19_53169708_01 +0000000003FFFFFF_4C7FFFFF_01 +FBFFFFFFFFEEFFFD_5F7BFFFF_01 +0000001E64BDFC55_51F325EF_01 +0000000001FFFFFF_4BFFFFFF_01 +FC00000001FFFFFE_5F7C0000_01 +0000D156A62AB849_575156A6_01 +0000000000FFFFFF_4B7FFFFF_00 +FFFFFFF83FEFFFFD_5F7FFFFF_01 +00035354EAE7C259_5854D53A_01 +00000000007FFFFF_4AFFFFFE_00 +FFFFFFFFFFFFFF7F_5F7FFFFF_01 +00000000F4DF3C75_4F74DF3C_01 +00000000003FFFFF_4A7FFFFC_00 +FFFA000000001FFF_5F7FFA00_01 +0000000000000003_40400000_00 +00000000001FFFFF_49FFFFF8_00 +FFFFFFFFFF7FFE40_5F7FFFFF_01 +0000005B5433CB9B_52B6A867_01 +00000000000FFFFF_497FFFF0_00 +FFFFFDFFDFFDFFFD_5F7FFFFD_01 +0000000000DEAE1F_4B5EAE1F_00 +000000000007FFFF_48FFFFE0_00 +FFFFFFFFF0080006_5F7FFFFF_01 +000000007735DEC7_4EEE6BBD_01 +000000000003FFFF_487FFFC0_00 +00000001FBFFFFFF_4FFDFFFF_01 +000007757D8B12ED_54EEAFB1_01 +000000000001FFFF_47FFFF80_00 +FFFFFE07F7FFFFFF_5F7FFFFE_01 +00002A654064E046_56299501_01 +000000000000FFFF_477FFF00_00 +08000000000017FF_5D000000_01 +0000000000000007_40E00000_00 +0000000000007FFF_46FFFE00_00 +07FFFFFFFFFFFDF6_5CFFFFFF_01 +00002D78B3D6C3B6_5635E2CF_01 +0000000000003FFF_467FFC00_00 +0000300004000000_56400010_00 +000000070B77F34F_50E16EFE_01 +0000000000001FFF_45FFF800_00 +FFFFFF80006FFFFE_5F7FFFFF_01 +0000093EB4D67EC8_5513EB4D_01 +0000000000000FFF_457FF000_00 +BFFFDFFFFBFFFFFF_5F3FFFDF_01 +0205CEAF34EA1DC7_5C0173AB_01 +00000000000007FF_44FFE000_00 +00004800007FFFFD_56900000_01 +0000000000000003_40400000_00 +00000000000003FF_447FC000_00 +0000000200001000_50000004_00 +00000000000760D0_48EC1A00_00 +00000000000001FF_43FF8000_00 +01003FFFFFFFFFFC_5B801FFF_01 +02C000708FF1BA51_5C30001C_01 +00000000000000FF_437F0000_00 +F802000003FFFFFF_5F780200_01 +4F9E07DCC0BDC061_5E9F3C0F_01 +000000000000007F_42FE0000_00 +03FF0000000000FF_5C7FC000_01 +00000001B9B2A079_4FDCD950_01 +000000000000003F_427C0000_00 +FFF80000000080FF_5F7FF800_01 +00000000005EB5B4_4ABD6B68_00 +000000000000001F_41F80000_00 +000000000077FBFE_4AEFF7FC_00 +0000000000DAC607_4B5AC607_00 +000000000000000F_41700000_00 +FFFFFFFEF80000FF_5F7FFFFF_01 +00000DC5B9D66984_555C5B9D_01 +0000000000000007_40E00000_00 +C001FFFFFFF00000_5F4001FF_01 +00003D06B372AA06_56741ACD_01 +0000000000000003_40400000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f64_rd.tv b/wally-pipelined/testbench/fp/ui64_f64_rd.tv new file mode 100644 index 000000000..857916e80 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f64_rd.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFD_01 +0000000072CC8B7A_41DCB322DE800000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_43EFFFFFFFF80007_01 +072C857F319EDE38_439CB215FCC67B78_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_43EFFFFF7FFFFF00_01 +00794C79B6D3007B_435E531E6DB4C01E_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_43EF7FFFFE000000_01 +0000000005AE458D_4196B91634000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +09EB456140D88764_43A3D68AC281B10E_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_43EFFFFC801FFFFF_01 +27DE834A248EDF36_43C3EF41A512476F_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +00000000000385E2_410C2F1000000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_43EE0083FFFFFFFF_01 +000000159EB1FD45_42359EB1FD450000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_43EFFFFFFFFFFF9F_01 +000000000002DDFE_4106EFF000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000002C89FF56B_420644FFAB580000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +3B5E4F0BE0DEBFF0_43CDAF2785F06F5F_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_43EFFFBF007FFFFF_01 +000000000004766B_4111D9AC00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000002C_4046000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +07E662A109109D0A_439F998A84244274_01 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_43E800000006FFFF_01 +0000000000000064_4059000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_43EF002000000200_00 +02114B79075F70EE_43808A5BC83AFB87_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000100_01 +0000000000000BAC_40A7580000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +000000C4A3A3DBE5_426894747B7CA000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_43EFFC0007DFFFFF_01 +0000000000001A91_40BA910000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_43EFFFFEF87FFFFF_01 +0000000000007309_40DCC24000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +0000000000000F58_40AEB00000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_43EFFFFFFBC03FFF_01 +0000000000006980_40DA600000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +00000000000000DD_406BA00000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +00008C23DA2CEAD8_42E1847B459D5B00_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_43EC0000000007FF_01 +00000DE3C1DEC43C_42ABC783BD887800_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_43EFFFE000017FFF_01 +000000008030FFBE_41E0061FF7C00000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_43EFFFC00000FFFD_01 +000000000FDEED86_41AFBDDB0C000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_43EE7FFFFFFFF7FF_01 +000000005DA3FF45_41D768FFD1400000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_43EFFFFFFFE00020_01 +000000009B1BCB54_41E363796A800000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +027DD19DE6563714_4383EE8CEF32B1B8_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_43EFF80000000800_01 +000000000003A359_410D1AC800000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +000000003E62EC20_41CF317610000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000685F_40DA17C000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_43EFFFFFFFF7FFFE_01 +00000836F99DBAA8_42A06DF33B755000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0073466832042D47_435CD19A0C810B51_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_43EFFFFFFFFFFFFF_01 +00000000007829C8_415E0A7200000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000001FB77C672B_423FB77C672B0000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFBFFFFFF_01 +0000000000005B78_40D6DE0000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_43EFEFFFFFFFFDFB_01 +00000000000000F1_406E200000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +0000000000000006_4018000000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +0008A60D9E19F17E_43214C1B3C33E2FC_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +0000000007506DBA_419D41B6E8000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_43EFFFFFFFFFFFDF_01 +0000000006A42AC9_419A90AB24000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +0007AA3F2BDACC89_431EA8FCAF6B3224_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_43EFFF0080000080_00 +0000000000000005_4014000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_43EFFFF000010000_01 +000DF681DECDADC9_432BED03BD9B5B92_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_43EFFFFFDFFFFC00_01 +0000000000004FBE_40D3EF8000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +00C01FECA24DE1B0_436803FD9449BC36_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_43EEFFFFFFFBFFEF_01 +0058A66761669936_43562999D859A64D_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_43EFFFDFF0000000_01 +0716EA43FAC45C97_439C5BA90FEB1172_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_43EFFFFFFFFFFFFF_01 +0064D70EC7661FD8_435935C3B1D987F6_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_43E80FFFFFFFFFFF_01 +00D956DBD0AEE817_436B2ADB7A15DD02_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F7FFFFFFF_01 +0000000000004300_40D0C00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +012EDF40F41F6021_4372EDF40F41F602_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_43EFF20000000000_01 +000000383DE950F6_424C1EF4A87B0000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_43E000007FFFFF80_00 +002B59CB3A604D69_4345ACE59D3026B4_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFEF_01 +000001A37C210862_427A37C210862000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +0000365CD8617789_42CB2E6C30BBC480_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +000000000000101D_40B01D0000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B000008000003F_01 +000000001D098D19_41BD098D19000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFAF_01 +000016B3BD2C7BEF_42B6B3BD2C7BEF00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +00004E5ADDDAA4A8_42D396B776A92A00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +0000000000000721_409C840000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +0000000000648262_4159209880000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_43E80003FFFFFFFF_01 +0000007353AC45D2_425CD4EB11748000_00 +8000000000000000_43E0000000000000_00 +FFFFFFFFFFE7EFFF_43EFFFFFFFFFFCFD_01 +0000000001A1202D_417A1202D0000000_00 +C000000000000000_43E8000000000000_00 +FFFFFFFFFFFF5F7F_43EFFFFFFFFFFFEB_01 +0000000000C0CA70_4168194E00000000_00 +E000000000000000_43EC000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000007B55D87D4_421ED5761F500000_00 +F000000000000000_43EE000000000000_00 +FF80000DFFFFFFFF_43EFF00001BFFFFF_01 +000000090510FAEF_42220A21F5DE0000_00 +F800000000000000_43EF000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000001724A_40F724A000000000_00 +FC00000000000000_43EF800000000000_00 +FFFFFFDF80000002_43EFFFFFFBF00000_01 +00000000000000E4_406C800000000000_00 +FE00000000000000_43EFC00000000000_00 +FEFFFFFFFFF800FE_43EFDFFFFFFFFF00_01 +00000002C6222702_4206311138100000_00 +FF00000000000000_43EFE00000000000_00 +0000000408000002_4210200000080000_00 +000002E96DF1CB41_42874B6F8E5A0800_00 +FF80000000000000_43EFF00000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE7F_01 +0727F174DEE7DC85_439C9FC5D37B9F72_01 +FFC0000000000000_43EFF80000000000_00 +8000000003FFFEFE_43E0000000007FFF_01 +000000000010BD5B_4130BD5B00000000_00 +FFE0000000000000_43EFFC0000000000_00 +0BEFFFFFFFFFFFFF_43A7DFFFFFFFFFFF_01 +000000000022790C_41413C8600000000_00 +FFF0000000000000_43EFFE0000000000_00 +FFFFFFFFFFEFFBFA_43EFFFFFFFFFFDFF_01 +000000369E75DF01_424B4F3AEF808000_00 +FFF8000000000000_43EFFF0000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000001E_403E000000000000_00 +FFFC000000000000_43EFFF8000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +0000000000328622_4149431100000000_00 +FFFE000000000000_43EFFFC000000000_00 +FFFFFF7FFFFDF7FF_43EFFFFFEFFFFFBE_01 +00172F0EC496FE21_43372F0EC496FE21_00 +FFFF000000000000_43EFFFE000000000_00 +DFBFFFFFFFFFFFFE_43EBF7FFFFFFFFFF_01 +0000000004FC1FCA_4193F07F28000000_00 +FFFF800000000000_43EFFFF000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +000F5194E4A9C2CE_432EA329C953859C_00 +FFFFC00000000000_43EFFFF800000000_00 +00000002100007FD_420080003FE80000_00 +000000000002D8FE_4106C7F000000000_00 +FFFFE00000000000_43EFFFFC00000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000003766E_410BB37000000000_00 +FFFFF00000000000_43EFFFFE00000000_00 +0040000400000002_4350000100000000_01 +000000000000F841_40EF082000000000_00 +FFFFF80000000000_43EFFFFF00000000_00 +3DFFFFFFFFFFFF7E_43CEFFFFFFFFFFFF_01 +0000000549E17E30_42152785F8C00000_00 +FFFFFC0000000000_43EFFFFF80000000_00 +FFFFFFFFFFFFFEE1_43EFFFFFFFFFFFFF_01 +0000000000000027_4043800000000000_00 +FFFFFE0000000000_43EFFFFFC0000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +0000000000000373_408B980000000000_00 +FFFFFF0000000000_43EFFFFFE0000000_00 +FD00000008000000_43EFA00000010000_00 +000000000005DBB1_41176EC400000000_00 +FFFFFF8000000000_43EFFFFFF0000000_00 +FFFFFFFFFFF8007F_43EFFFFFFFFFFF00_01 +00000002FD10A515_4207E88528A80000_00 +FFFFFFC000000000_43EFFFFFF8000000_00 +FFEFFFFFFFFFFFFE_43EFFDFFFFFFFFFF_01 +0AB02984F6283B6C_43A5605309EC5076_01 +FFFFFFE000000000_43EFFFFFFC000000_00 +FFFFFFBC000001FE_43EFFFFFF7800000_01 +00B087C6B9FE7FE0_436610F8D73FCFFC_00 +FFFFFFF000000000_43EFFFFFFE000000_00 +FFF80001000007FE_43EFFF0000200000_01 +01F2762EA6837956_437F2762EA683795_01 +FFFFFFF800000000_43EFFFFFFF000000_00 +FFF7E0FFFFFFFFFE_43EFFEFC1FFFFFFF_01 +00022E1175484626_4301708BAA423130_00 +FFFFFFFC00000000_43EFFFFFFF800000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000168F_40B68F0000000000_00 +FFFFFFFE00000000_43EFFFFFFFC00000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFDFFF_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFF00000000_43EFFFFFFFE00000_00 +FFFFFFD0000FFFFD_43EFFFFFFA0001FF_01 +000001BDF6658B83_427BDF6658B83000_00 +FFFFFFFF80000000_43EFFFFFFFF00000_00 +1000001FFDFFFFFF_43B000001FFDFFFF_01 +000000000000BB5B_40E76B6000000000_00 +FFFFFFFFC0000000_43EFFFFFFFF80000_00 +FFFFFFBFFE0FFFFF_43EFFFFFF7FFC1FF_01 +0000000000000000_0000000000000000_00 +FFFFFFFFE0000000_43EFFFFFFFFC0000_00 +FFFFFFFBF00007FF_43EFFFFFFF7E0000_01 +01E986274F48EAAD_437E986274F48EAA_01 +FFFFFFFFF0000000_43EFFFFFFFFE0000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFDFFFFFF_01 +000000000000CB5A_40E96B4000000000_00 +FFFFFFFFF8000000_43EFFFFFFFFF0000_00 +7FF000000000FFFF_43DFFC000000003F_01 +0000000BC2717FC3_422784E2FF860000_00 +FFFFFFFFFC000000_43EFFFFFFFFF8000_00 +FFFFFFE00008001F_43EFFFFFFC000100_01 +00000000000FABDA_412F57B400000000_00 +FFFFFFFFFE000000_43EFFFFFFFFFC000_00 +0200000000000002_4380000000000000_01 +0000000000FDA53F_416FB4A7E0000000_00 +FFFFFFFFFF000000_43EFFFFFFFFFE000_00 +F6000003FFFFFFFE_43EEC000007FFFFF_01 +0000000000000010_4030000000000000_00 +FFFFFFFFFF800000_43EFFFFFFFFFF000_00 +FFFFFFFFFFBFFF7E_43EFFFFFFFFFF7FF_01 +00000001EE0FEA62_41FEE0FEA6200000_00 +FFFFFFFFFFC00000_43EFFFFFFFFFF800_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000077F35EDC1D_425DFCD7B7074000_00 +FFFFFFFFFFE00000_43EFFFFFFFFFFC00_00 +FFFFFFF7FDFFFF7D_43EFFFFFFEFFBFFF_01 +00000000000003AD_408D680000000000_00 +FFFFFFFFFFF00000_43EFFFFFFFFFFE00_00 +FFFFFF0000100020_43EFFFFFE0000200_01 +67F167FBC7FC5F9A_43D9FC59FEF1FF17_01 +FFFFFFFFFFF80000_43EFFFFFFFFFFF00_00 +003FFFFFFFFC0001_434FFFFFFFFE0000_01 +002E48F9F4EBD30E_4347247CFA75E987_00 +FFFFFFFFFFFC0000_43EFFFFFFFFFFF80_00 +DFFFFFFFFFFBFFFE_43EBFFFFFFFFFF7F_01 +0091C23EE8C9424F_43623847DD192849_01 +FFFFFFFFFFFE0000_43EFFFFFFFFFFFC0_00 +F7DFFBFFFFFFFFFE_43EEFBFF7FFFFFFF_01 +00000000ACAE080C_41E595C101800000_00 +FFFFFFFFFFFF0000_43EFFFFFFFFFFFE0_00 +FFFFC00010000020_43EFFFF800020000_01 +0CD921F917B20E40_43A9B243F22F641C_01 +FFFFFFFFFFFF8000_43EFFFFFFFFFFFF0_00 +F8000FFFFFFFFFFD_43EF0001FFFFFFFF_01 +00017C566BC7D811_42F7C566BC7D8110_00 +FFFFFFFFFFFFC000_43EFFFFFFFFFFFF8_00 +00000000000000FE_406FC00000000000_00 +00F82AC14930D386_436F055829261A70_01 +FFFFFFFFFFFFE000_43EFFFFFFFFFFFFC_00 +00000000000003FC_408FE00000000000_00 +008E62EC60E119FC_4361CC5D8C1C233F_01 +FFFFFFFFFFFFF000_43EFFFFFFFFFFFFE_00 +FFFFEFF7FF7FFFFE_43EFFFFDFEFFEFFF_01 +1E2B1ECF210EEDC5_43BE2B1ECF210EED_01 +FFFFFFFFFFFFF800_43EFFFFFFFFFFFFF_00 +00000000007FFF1F_415FFFC7C0000000_00 +000006534F5676F7_42994D3D59DBDC00_00 +FFFFFFFFFFFFFC00_43EFFFFFFFFFFFFF_01 +0000001004FFFFFD_423004FFFFFD0000_00 +0000435C939669F1_42D0D724E59A7C40_00 +FFFFFFFFFFFFFE00_43EFFFFFFFFFFFFF_01 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFD_01 +0000000000000011_4031000000000000_00 +FFFFFFFFFFFFFF00_43EFFFFFFFFFFFFF_01 +01FFFFFFFBFFEFFE_437FFFFFFFBFFEFF_01 +000000000000036E_408B700000000000_00 +FFFFFFFFFFFFFF80_43EFFFFFFFFFFFFF_01 +FFF7FFFFFFFFF7FD_43EFFEFFFFFFFFFE_01 +000038E2BCFAC553_42CC715E7D62A980_00 +FFFFFFFFFFFFFFC0_43EFFFFFFFFFFFFF_01 +FFFFFBFFFFFE0FFE_43EFFFFF7FFFFFC1_01 +00000009A4E704BF_422349CE097E0000_00 +FFFFFFFFFFFFFFE0_43EFFFFFFFFFFFFF_01 +1400007FFFFFFFFD_43B400007FFFFFFF_01 +0000000093B187B4_41E27630F6800000_00 +FFFFFFFFFFFFFFF0_43EFFFFFFFFFFFFF_01 +40000000007FFFFD_43D0000000001FFF_01 +0000000000E7D468_416CFA8D00000000_00 +FFFFFFFFFFFFFFF8_43EFFFFFFFFFFFFF_01 +007FFEFFFFFBFFFE_435FFFBFFFFEFFFF_01 +000000026CEC79F8_42036763CFC00000_00 +FFFFFFFFFFFFFFFC_43EFFFFFFFFFFFFF_01 +00FFFFFF000000FF_436FFFFFE000001F_01 +0000000000D3983A_416A730740000000_00 +FFFFFFFFFFFFFFFE_43EFFFFFFFFFFFFF_01 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +00000001F4A7088A_41FF4A7088A00000_00 +FFFFFFFFFFFFFFFF_43EFFFFFFFFFFFFF_01 +000008000000027E_42A000000004FC00_00 +000000000001F4E8_40FF4E8000000000_00 +FFFFFFFFFFFFFFFD_43EFFFFFFFFFFFFF_01 +FFFFFFFFFF83FFDF_43EFFFFFFFFFF07F_01 +00001E11407887B2_42BE11407887B200_00 +FFFFFFFFFFFFFFFB_43EFFFFFFFFFFFFF_01 +04000003FFFFFFF6_439000000FFFFFFF_01 +0000000000000D13_40AA260000000000_00 +FFFFFFFFFFFFFFF7_43EFFFFFFFFFFFFF_01 +BFFC00000000003E_43E7FF8000000000_01 +00000028D7BBB75B_42446BDDDBAD8000_00 +FFFFFFFFFFFFFFEF_43EFFFFFFFFFFFFF_01 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +0000000000CD5A23_4169AB4460000000_00 +FFFFFFFFFFFFFFDF_43EFFFFFFFFFFFFF_01 +FFBFDFFFBFFFFFFF_43EFF7FBFFF7FFFF_01 +00000000000000FF_406FE00000000000_00 +FFFFFFFFFFFFFFBF_43EFFFFFFFFFFFFF_01 +00000007FF800003_421FFE00000C0000_00 +00000000000ABB02_4125760400000000_00 +FFFFFFFFFFFFFF7F_43EFFFFFFFFFFFFF_01 +FFFFFFFFFFFEE7FF_43EFFFFFFFFFFFDC_01 +00664B2B9BAD0DA2_435992CAE6EB4368_01 +FFFFFFFFFFFFFEFF_43EFFFFFFFFFFFFF_01 +0000000000100803_4130080300000000_00 +009B1DCB9F857D5E_436363B973F0AFAB_01 +FFFFFFFFFFFFFDFF_43EFFFFFFFFFFFFF_01 +FFFFFFBFFFFFEFEE_43EFFFFFF7FFFFFD_01 +36FD7542899C1C6F_43CB7EBAA144CE0E_01 +FFFFFFFFFFFFFBFF_43EFFFFFFFFFFFFF_01 +FF800000004001FF_43EFF00000000800_01 +0000000006BE4932_419AF924C8000000_00 +FFFFFFFFFFFFF7FF_43EFFFFFFFFFFFFE_01 +00001004000FFFFE_42B004000FFFFE00_00 +0000001DAA0123E0_423DAA0123E00000_00 +FFFFFFFFFFFFEFFF_43EFFFFFFFFFFFFD_01 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +00001C8703B1DCB0_42BC8703B1DCB000_00 +FFFFFFFFFFFFDFFF_43EFFFFFFFFFFFFB_01 +FE0FE00000000000_43EFC1FC00000000_00 +0F79ED944A4E2779_43AEF3DB28949C4E_01 +FFFFFFFFFFFFBFFF_43EFFFFFFFFFFFF7_01 +FBFFFE0400000000_43EF7FFFC0800000_00 +0000030127E03666_4288093F01B33000_00 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFEF_01 +FFFFF0200000FFFE_43EFFFFE0400001F_01 +000000000000017F_4077F00000000000_00 +FFFFFFFFFFFEFFFF_43EFFFFFFFFFFFDF_01 +FFEFFE0000080000_43EFFDFFC0000100_00 +00000000013354EA_4173354EA0000000_00 +FFFFFFFFFFFDFFFF_43EFFFFFFFFFFFBF_01 +003FF0000003FFFE_434FF8000001FFFF_00 +0000016375B23F7B_4276375B23F7B000_00 +FFFFFFFFFFFBFFFF_43EFFFFFFFFFFF7F_01 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000192117F38_41F92117F3800000_00 +FFFFFFFFFFF7FFFF_43EFFFFFFFFFFEFF_01 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFEF_01 +00000000000018BE_40B8BE0000000000_00 +FFFFFFFFFFEFFFFF_43EFFFFFFFFFFDFF_01 +004000020FFFFFFF_4350000083FFFFFF_01 +0000B84C2D8BC9CB_42E70985B1793960_00 +FFFFFFFFFFDFFFFF_43EFFFFFFFFFFBFF_01 +00FFFFFFFFFFFFFD_436FFFFFFFFFFFFF_01 +00000223C2C6F284_42811E1637942000_00 +FFFFFFFFFFBFFFFF_43EFFFFFFFFFF7FF_01 +FFFDDFFFFFFFFFFD_43EFFFBBFFFFFFFF_01 +00000000F46356C4_41EE8C6AD8800000_00 +FFFFFFFFFF7FFFFF_43EFFFFFFFFFEFFF_01 +010000000000BFFF_4370000000000BFF_01 +0000000000000005_4014000000000000_00 +FFFFFFFFFEFFFFFF_43EFFFFFFFFFDFFF_01 +FFFFBF7FFBFFFFFE_43EFFFF7EFFF7FFF_01 +00000026386CE889_42431C3674448000_00 +FFFFFFFFFDFFFFFF_43EFFFFFFFFFBFFF_01 +F00000F7FFFFFFFF_43EE00001EFFFFFF_01 +0001FC53090C46A4_42FFC53090C46A40_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF7FFF_01 +0000000000800047_41600008E0000000_00 +000000001693872E_41B693872E000000_00 +FFFFFFFFF7FFFFFF_43EFFFFFFFFEFFFF_01 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000226A7845E35_4281353C22F1A800_00 +FFFFFFFFEFFFFFFF_43EFFFFFFFFDFFFF_01 +FFFFFFDFFFFFFBFD_43EFFFFFFBFFFFFF_01 +000000005433D14C_41D50CF453000000_00 +FFFFFFFFDFFFFFFF_43EFFFFFFFFBFFFF_01 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +00F23E8068D3D84A_436E47D00D1A7B09_01 +FFFFFFFFBFFFFFFF_43EFFFFFFFF7FFFF_01 +F7FFBFFFFFFFBFFF_43EEFFF7FFFFFFF7_01 +0000BD29B7459087_42E7A536E8B210E0_00 +FFFFFFFF7FFFFFFF_43EFFFFFFFEFFFFF_01 +FFFFFFF8FFFFBFFF_43EFFFFFFF1FFFF7_01 +00000000002DDC06_4146EE0300000000_00 +FFFFFFFEFFFFFFFF_43EFFFFFFFDFFFFF_01 +FFFFFFF80001FFFF_43EFFFFFFF00003F_01 +0000000000012FF9_40F2FF9000000000_00 +FFFFFFFDFFFFFFFF_43EFFFFFFFBFFFFF_01 +004000040000FFFF_4350000100003FFF_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFBFFFFFFFF_43EFFFFFFF7FFFFF_01 +C0000000007FFFFA_43E8000000000FFF_01 +0000000006053E2B_419814F8AC000000_00 +FFFFFFF7FFFFFFFF_43EFFFFFFEFFFFFF_01 +7FFE000007FFFFFF_43DFFF800001FFFF_01 +000000000000002D_4046800000000000_00 +FFFFFFEFFFFFFFFF_43EFFFFFFDFFFFFF_01 +F80000000001007E_43EF000000000020_01 +00000D48424AD9D6_42AA908495B3AC00_00 +FFFFFFDFFFFFFFFF_43EFFFFFFBFFFFFF_01 +FFFFFE0001FEFFFF_43EFFFFFC0003FDF_01 +000000000000033B_4089D80000000000_00 +FFFFFFBFFFFFFFFF_43EFFFFFF7FFFFFF_01 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0243_01 +FFFFFF7FFFFFFFFF_43EFFFFFEFFFFFFF_01 +00FFF7FFFF7FFFFE_436FFEFFFFEFFFFF_01 +0000000000000086_4060C00000000000_00 +FFFFFEFFFFFFFFFF_43EFFFFFDFFFFFFF_01 +FBFFFFBFFFBFFFFF_43EF7FFFF7FFF7FF_01 +00000000000021BA_40C0DD0000000000_00 +FFFFFDFFFFFFFFFF_43EFFFFFBFFFFFFF_01 +0000000040000082_41D0000020800000_00 +0007A2BF5B689F89_431E8AFD6DA27E24_00 +FFFFFBFFFFFFFFFF_43EFFFFF7FFFFFFF_01 +0000001FF8000008_423FF80000080000_00 +387CAA7DE672DE8B_43CC3E553EF3396F_01 +FFFFF7FFFFFFFFFF_43EFFFFEFFFFFFFF_01 +07FFF80000000002_439FFFE000000000_01 +0000000030A1E5B8_41C850F2DC000000_00 +FFFFEFFFFFFFFFFF_43EFFFFDFFFFFFFF_01 +F7FFFFE00007FFFF_43EEFFFFFC0000FF_01 +000000000006ADFC_411AB7F000000000_00 +FFFFDFFFFFFFFFFF_43EFFFFBFFFFFFFF_01 +FFFFFF03FFFFFFC0_43EFFFFFE07FFFFF_01 +0A579475948F0032_43A4AF28EB291E00_01 +FFFFBFFFFFFFFFFF_43EFFFF7FFFFFFFF_01 +FC00000000003FF6_43EF800000000007_01 +00AE677AC313BF60_4365CCEF586277EC_00 +FFFF7FFFFFFFFFFF_43EFFFEFFFFFFFFF_01 +02000007FF7FFFFF_438000003FFBFFFF_01 +0000002E999639F1_42474CCB1CF88000_00 +FFFEFFFFFFFFFFFF_43EFFFDFFFFFFFFF_01 +FFFF83FFFFFFFFBE_43EFFFF07FFFFFFF_01 +000000000003537D_410A9BE800000000_00 +FFFDFFFFFFFFFFFF_43EFFFBFFFFFFFFF_01 +EFFFFFC00000003D_43EDFFFFF8000000_01 +000000121FEDFD35_42321FEDFD350000_00 +FFFBFFFFFFFFFFFF_43EFFF7FFFFFFFFF_01 +FFFFFFF0000007FE_43EFFFFFFE000000_01 +00000000001E0839_413E083900000000_00 +FFF7FFFFFFFFFFFF_43EFFEFFFFFFFFFF_01 +0000007FFFE000FF_425FFFF8003FC000_00 +0000000079F30F48_41DE7CC3D2000000_00 +FFEFFFFFFFFFFFFF_43EFFDFFFFFFFFFF_01 +FFFFFC13FFFFFFFD_43EFFFFF827FFFFF_01 +0000000000003B85_40CDC28000000000_00 +FFDFFFFFFFFFFFFF_43EFFBFFFFFFFFFF_01 +000008000007FFFE_42A000000FFFFC00_00 +32DB4409E5AE87E6_43C96DA204F2D743_01 +FFBFFFFFFFFFFFFF_43EFF7FFFFFFFFFF_01 +FFFFFFFFFFF7BFEE_43EFFFFFFFFFFEF7_01 +000000000000003D_404E800000000000_00 +FF7FFFFFFFFFFFFF_43EFEFFFFFFFFFFF_01 +000000001040FFFE_41B040FFFE000000_00 +00004909A09C13D3_42D242682704F4C0_00 +FEFFFFFFFFFFFFFF_43EFDFFFFFFFFFFF_01 +FFFFFF01FFFFFF7F_43EFFFFFE03FFFFF_01 +00000072E7D2575D_425CB9F495D74000_00 +FDFFFFFFFFFFFFFF_43EFBFFFFFFFFFFF_01 +FFFFFFFFFFFEFFDB_43EFFFFFFFFFFFDF_01 +0000000000000057_4055C00000000000_00 +FBFFFFFFFFFFFFFF_43EF7FFFFFFFFFFF_01 +100000001FFFFFF6_43B00000001FFFFF_01 +000000914B12EF51_426229625DEA2000_00 +F7FFFFFFFFFFFFFF_43EEFFFFFFFFFFFF_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFB_01 +000000769F3A5C2C_425DA7CE970B0000_00 +EFFFFFFFFFFFFFFF_43EDFFFFFFFFFFFF_01 +FFFFFFFDF7FFFFFD_43EFFFFFFFBEFFFF_01 +0000000000000002_4000000000000000_00 +DFFFFFFFFFFFFFFF_43EBFFFFFFFFFFFF_01 +FFFFFFFFFE0007FF_43EFFFFFFFFFC000_01 +000000000000009E_4063C00000000000_00 +BFFFFFFFFFFFFFFF_43E7FFFFFFFFFFFF_01 +FFF800000009FFFF_43EFFF000000013F_01 +0000000000087AA4_4120F54800000000_00 +7FFFFFFFFFFFFFFF_43DFFFFFFFFFFFFF_01 +4080000000FFFFFF_43D0200000003FFF_01 +000000001DE7601D_41BDE7601D000000_00 +3FFFFFFFFFFFFFFF_43CFFFFFFFFFFFFF_01 +FFCFFFFFFFBFFFFE_43EFF9FFFFFFF7FF_01 +000000000000004A_4052800000000000_00 +1FFFFFFFFFFFFFFF_43BFFFFFFFFFFFFF_01 +000080400000003F_42E00800000007E0_00 +00000000003F75A5_414FBAD280000000_00 +0FFFFFFFFFFFFFFF_43AFFFFFFFFFFFFF_01 +FFFFFFEFFFFFCFFE_43EFFFFFFDFFFFF9_01 +000000E775887420_426CEEB10E840000_00 +07FFFFFFFFFFFFFF_439FFFFFFFFFFFFF_01 +00000000000801FE_412003FC00000000_00 +0000000000A13FF1_416427FE20000000_00 +03FFFFFFFFFFFFFF_438FFFFFFFFFFFFF_01 +07FEFFFFFFFFFFEE_439FFBFFFFFFFFFF_01 +000000000000000C_4028000000000000_00 +01FFFFFFFFFFFFFF_437FFFFFFFFFFFFF_01 +0000000820000003_4220400000060000_00 +00000001AD105214_41FAD10521400000_00 +00FFFFFFFFFFFFFF_436FFFFFFFFFFFFF_01 +FFFFF00FFFFFFFBE_43EFFFFE01FFFFFF_01 +0000000000CC48E7_4169891CE0000000_00 +007FFFFFFFFFFFFF_435FFFFFFFFFFFFF_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +00000000000BA6CB_41274D9600000000_00 +003FFFFFFFFFFFFF_434FFFFFFFFFFFFF_01 +FFFFFF7FBFFFFFBF_43EFFFFFEFF7FFFF_01 +0000000000024425_4102212800000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFDFF_01 +0000004E7115EC53_42539C457B14C000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_43EFFFFF007FFFFF_01 +0000002E539ADCFE_424729CD6E7F0000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF7FFF_01 +000000D5084732F3_426AA108E65E6000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_43E7FFEFFFFFFFFF_01 +0000000000000543_40950C0000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +000000000000491B_40D246C000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_43EF800400000003_01 +0000016898822A24_4276898822A24000_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF81FFFFFFFF_01 +0000000FFE18C7BF_422FFC318F7E0000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_43EFFFFFDFFFDFFF_01 +02F03620C1266ED9_438781B106093376_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_43E7EFDFFFFFFFFF_01 +0000000000000055_4055400000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_43EFFF7FFFFF007F_01 +0000000000168684_4136868400000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_43EBFFFFFC000000_01 +0000000000000CF5_40A9EA0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_43EFFFE00800001F_01 +0000000000000022_4041000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_43EF7FFFFFFFFFF7_01 +0000000000001BC9_40BBC90000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_43E00FFFFFFFFFFB_01 +000274E35A70CD76_4303A71AD3866BB0_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFDFFFF_01 +0000000300E73AFC_42080739D7E00000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_43EFF80000000020_01 +00000000000615E9_411857A400000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +00000000000000B3_4066600000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +0000006E6B141E1B_425B9AC50786C000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_43EFFFFFFFFEC000_01 +00000003AB310BA6_420D59885D300000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +0000000000000195_4079500000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_43EFFFFFFFF00000_01 +00000059BA8D5559_42566EA355564000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_43EF7FDFFFFFFFFF_01 +000001B6F062822D_427B6F062822D000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +03CEAD9E2FB104A4_438E756CF17D8825_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +000000000D681E78_41AAD03CF0000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000058_4056000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000000_01 +0000000000000095_4062A00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000BFFFFFFFF_01 +0000009697087B19_4262D2E10F632000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_43EF7FFFFFFFFDDF_01 +0000001E64BDFC55_423E64BDFC550000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_43EF800000003FFF_01 +0000D156A62AB849_42EA2AD4C5570920_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_43EFFFFFFF07FDFF_01 +00035354EAE7C259_430A9AA7573E12C8_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_43EFFFFFFFFFFFFF_01 +00000000F4DF3C75_41EE9BE78EA00000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_43EFFF4000000003_01 +0000000000000003_4008000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_43EFFFFFFFFFEFFF_01 +0000005B5433CB9B_4256D50CF2E6C000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_43EFFFFFBFFBFFBF_01 +0000000000DEAE1F_416BD5C3E0000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_43EFFFFFFFFE0100_01 +000000007735DEC7_41DDCD77B1C00000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000007757D8B12ED_429DD5F62C4BB400_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_43EFFFFFC0FEFFFF_01 +00002A654064E046_42C532A032702300_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A000000000002F_01 +0000000000000007_401C000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF7_01 +00002D78B3D6C3B6_42C6BC59EB61DB00_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +000000070B77F34F_421C2DDFCD3C0000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_43EFFFFFF0000DFF_01 +0000093EB4D67EC8_42A27D69ACFD9000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_43E7FFFBFFFF7FFF_01 +0205CEAF34EA1DC7_43802E7579A750EE_01 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +0000000000000003_4008000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000760D0_411D834000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_437003FFFFFFFFFF_01 +02C000708FF1BA51_43860003847F8DD2_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_43EF004000007FFF_01 +4F9E07DCC0BDC061_43D3E781F7302F70_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000007_01 +00000001B9B2A079_41FB9B2A07900000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_43EFFF0000000010_01 +00000000005EB5B4_4157AD6D00000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +0000000000DAC607_416B58C0E0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_43EFFFFFFFDF0000_01 +00000DC5B9D66984_42AB8B73ACD30800_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_43E8003FFFFFFE00_00 +00003D06B372AA06_42CE8359B9550300_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f64_rne.tv b/wally-pipelined/testbench/fp/ui64_f64_rne.tv new file mode 100644 index 000000000..ef22e12a4 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f64_rne.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFE_01 +0000000072CC8B7A_41DCB322DE800000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_43EFFFFFFFF80008_01 +072C857F319EDE38_439CB215FCC67B79_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_43EFFFFF7FFFFF00_01 +00794C79B6D3007B_435E531E6DB4C01F_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_43EF7FFFFE000000_01 +0000000005AE458D_4196B91634000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +09EB456140D88764_43A3D68AC281B10F_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_43EFFFFC80200000_01 +27DE834A248EDF36_43C3EF41A5124770_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +00000000000385E2_410C2F1000000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_43EE008400000000_01 +000000159EB1FD45_42359EB1FD450000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_43EFFFFFFFFFFFA0_01 +000000000002DDFE_4106EFF000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000002C89FF56B_420644FFAB580000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +3B5E4F0BE0DEBFF0_43CDAF2785F06F60_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_43EFFFBF00800000_01 +000000000004766B_4111D9AC00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000002C_4046000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +07E662A109109D0A_439F998A84244274_01 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_43E8000000070000_01 +0000000000000064_4059000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_43EF002000000200_00 +02114B79075F70EE_43808A5BC83AFB87_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000100_01 +0000000000000BAC_40A7580000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +000000C4A3A3DBE5_426894747B7CA000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_43EFFC0007E00000_01 +0000000000001A91_40BA910000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_43EFFFFEF8800000_01 +0000000000007309_40DCC24000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +0000000000000F58_40AEB00000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_43EFFFFFFBC04000_01 +0000000000006980_40DA600000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +00000000000000DD_406BA00000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +00008C23DA2CEAD8_42E1847B459D5B00_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_43EC000000000800_01 +00000DE3C1DEC43C_42ABC783BD887800_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_43EFFFE000018000_01 +000000008030FFBE_41E0061FF7C00000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_43EFFFC00000FFFE_01 +000000000FDEED86_41AFBDDB0C000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_43EE7FFFFFFFF800_01 +000000005DA3FF45_41D768FFD1400000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_43EFFFFFFFE00020_01 +000000009B1BCB54_41E363796A800000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +027DD19DE6563714_4383EE8CEF32B1B9_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_43EFF80000000801_01 +000000000003A359_410D1AC800000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +000000003E62EC20_41CF317610000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000685F_40DA17C000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_43EFFFFFFFF7FFFE_01 +00000836F99DBAA8_42A06DF33B755000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0073466832042D47_435CD19A0C810B52_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_43EFFFFFFFFFFFFF_01 +00000000007829C8_415E0A7200000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000001FB77C672B_423FB77C672B0000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFC000000_01 +0000000000005B78_40D6DE0000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_43EFEFFFFFFFFDFC_01 +00000000000000F1_406E200000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +0000000000000006_4018000000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +0008A60D9E19F17E_43214C1B3C33E2FC_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +0000000007506DBA_419D41B6E8000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_43EFFFFFFFFFFFDF_01 +0000000006A42AC9_419A90AB24000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +0007AA3F2BDACC89_431EA8FCAF6B3224_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_43EFFF0080000080_00 +0000000000000005_4014000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_43EFFFF000010000_01 +000DF681DECDADC9_432BED03BD9B5B92_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_43EFFFFFDFFFFC00_01 +0000000000004FBE_40D3EF8000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +00C01FECA24DE1B0_436803FD9449BC36_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_43EEFFFFFFFBFFF0_01 +0058A66761669936_43562999D859A64E_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_43EFFFDFF0000000_01 +0716EA43FAC45C97_439C5BA90FEB1172_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_43F0000000000000_01 +0064D70EC7661FD8_435935C3B1D987F6_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_43E8100000000000_01 +00D956DBD0AEE817_436B2ADB7A15DD03_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F80000000_01 +0000000000004300_40D0C00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +012EDF40F41F6021_4372EDF40F41F602_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_43EFF20000000000_01 +000000383DE950F6_424C1EF4A87B0000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_43E000007FFFFF80_00 +002B59CB3A604D69_4345ACE59D3026B4_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFF0_01 +000001A37C210862_427A37C210862000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +0000365CD8617789_42CB2E6C30BBC480_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +000000000000101D_40B01D0000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B0000080000040_01 +000000001D098D19_41BD098D19000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFB0_01 +000016B3BD2C7BEF_42B6B3BD2C7BEF00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +00004E5ADDDAA4A8_42D396B776A92A00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +0000000000000721_409C840000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +0000000000648262_4159209880000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_43E8000400000000_01 +0000007353AC45D2_425CD4EB11748000_00 +8000000000000000_43E0000000000000_00 +FFFFFFFFFFE7EFFF_43EFFFFFFFFFFCFE_01 +0000000001A1202D_417A1202D0000000_00 +C000000000000000_43E8000000000000_00 +FFFFFFFFFFFF5F7F_43EFFFFFFFFFFFEC_01 +0000000000C0CA70_4168194E00000000_00 +E000000000000000_43EC000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000007B55D87D4_421ED5761F500000_00 +F000000000000000_43EE000000000000_00 +FF80000DFFFFFFFF_43EFF00001C00000_01 +000000090510FAEF_42220A21F5DE0000_00 +F800000000000000_43EF000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000001724A_40F724A000000000_00 +FC00000000000000_43EF800000000000_00 +FFFFFFDF80000002_43EFFFFFFBF00000_01 +00000000000000E4_406C800000000000_00 +FE00000000000000_43EFC00000000000_00 +FEFFFFFFFFF800FE_43EFDFFFFFFFFF00_01 +00000002C6222702_4206311138100000_00 +FF00000000000000_43EFE00000000000_00 +0000000408000002_4210200000080000_00 +000002E96DF1CB41_42874B6F8E5A0800_00 +FF80000000000000_43EFF00000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE80_01 +0727F174DEE7DC85_439C9FC5D37B9F72_01 +FFC0000000000000_43EFF80000000000_00 +8000000003FFFEFE_43E0000000008000_01 +000000000010BD5B_4130BD5B00000000_00 +FFE0000000000000_43EFFC0000000000_00 +0BEFFFFFFFFFFFFF_43A7E00000000000_01 +000000000022790C_41413C8600000000_00 +FFF0000000000000_43EFFE0000000000_00 +FFFFFFFFFFEFFBFA_43EFFFFFFFFFFDFF_01 +000000369E75DF01_424B4F3AEF808000_00 +FFF8000000000000_43EFFF0000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000001E_403E000000000000_00 +FFFC000000000000_43EFFF8000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +0000000000328622_4149431100000000_00 +FFFE000000000000_43EFFFC000000000_00 +FFFFFF7FFFFDF7FF_43EFFFFFEFFFFFBF_01 +00172F0EC496FE21_43372F0EC496FE21_00 +FFFF000000000000_43EFFFE000000000_00 +DFBFFFFFFFFFFFFE_43EBF80000000000_01 +0000000004FC1FCA_4193F07F28000000_00 +FFFF800000000000_43EFFFF000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +000F5194E4A9C2CE_432EA329C953859C_00 +FFFFC00000000000_43EFFFF800000000_00 +00000002100007FD_420080003FE80000_00 +000000000002D8FE_4106C7F000000000_00 +FFFFE00000000000_43EFFFFC00000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000003766E_410BB37000000000_00 +FFFFF00000000000_43EFFFFE00000000_00 +0040000400000002_4350000100000000_01 +000000000000F841_40EF082000000000_00 +FFFFF80000000000_43EFFFFF00000000_00 +3DFFFFFFFFFFFF7E_43CF000000000000_01 +0000000549E17E30_42152785F8C00000_00 +FFFFFC0000000000_43EFFFFF80000000_00 +FFFFFFFFFFFFFEE1_43F0000000000000_01 +0000000000000027_4043800000000000_00 +FFFFFE0000000000_43EFFFFFC0000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +0000000000000373_408B980000000000_00 +FFFFFF0000000000_43EFFFFFE0000000_00 +FD00000008000000_43EFA00000010000_00 +000000000005DBB1_41176EC400000000_00 +FFFFFF8000000000_43EFFFFFF0000000_00 +FFFFFFFFFFF8007F_43EFFFFFFFFFFF00_01 +00000002FD10A515_4207E88528A80000_00 +FFFFFFC000000000_43EFFFFFF8000000_00 +FFEFFFFFFFFFFFFE_43EFFE0000000000_01 +0AB02984F6283B6C_43A5605309EC5077_01 +FFFFFFE000000000_43EFFFFFFC000000_00 +FFFFFFBC000001FE_43EFFFFFF7800000_01 +00B087C6B9FE7FE0_436610F8D73FCFFC_00 +FFFFFFF000000000_43EFFFFFFE000000_00 +FFF80001000007FE_43EFFF0000200001_01 +01F2762EA6837956_437F2762EA683795_01 +FFFFFFF800000000_43EFFFFFFF000000_00 +FFF7E0FFFFFFFFFE_43EFFEFC20000000_01 +00022E1175484626_4301708BAA423130_00 +FFFFFFFC00000000_43EFFFFFFF800000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000168F_40B68F0000000000_00 +FFFFFFFE00000000_43EFFFFFFFC00000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFE000_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFF00000000_43EFFFFFFFE00000_00 +FFFFFFD0000FFFFD_43EFFFFFFA000200_01 +000001BDF6658B83_427BDF6658B83000_00 +FFFFFFFF80000000_43EFFFFFFFF00000_00 +1000001FFDFFFFFF_43B000001FFE0000_01 +000000000000BB5B_40E76B6000000000_00 +FFFFFFFFC0000000_43EFFFFFFFF80000_00 +FFFFFFBFFE0FFFFF_43EFFFFFF7FFC200_01 +0000000000000000_0000000000000000_00 +FFFFFFFFE0000000_43EFFFFFFFFC0000_00 +FFFFFFFBF00007FF_43EFFFFFFF7E0001_01 +01E986274F48EAAD_437E986274F48EAB_01 +FFFFFFFFF0000000_43EFFFFFFFFE0000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFDFFFFFF_01 +000000000000CB5A_40E96B4000000000_00 +FFFFFFFFF8000000_43EFFFFFFFFF0000_00 +7FF000000000FFFF_43DFFC0000000040_01 +0000000BC2717FC3_422784E2FF860000_00 +FFFFFFFFFC000000_43EFFFFFFFFF8000_00 +FFFFFFE00008001F_43EFFFFFFC000100_01 +00000000000FABDA_412F57B400000000_00 +FFFFFFFFFE000000_43EFFFFFFFFFC000_00 +0200000000000002_4380000000000000_01 +0000000000FDA53F_416FB4A7E0000000_00 +FFFFFFFFFF000000_43EFFFFFFFFFE000_00 +F6000003FFFFFFFE_43EEC00000800000_01 +0000000000000010_4030000000000000_00 +FFFFFFFFFF800000_43EFFFFFFFFFF000_00 +FFFFFFFFFFBFFF7E_43EFFFFFFFFFF800_01 +00000001EE0FEA62_41FEE0FEA6200000_00 +FFFFFFFFFFC00000_43EFFFFFFFFFF800_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000077F35EDC1D_425DFCD7B7074000_00 +FFFFFFFFFFE00000_43EFFFFFFFFFFC00_00 +FFFFFFF7FDFFFF7D_43EFFFFFFEFFC000_01 +00000000000003AD_408D680000000000_00 +FFFFFFFFFFF00000_43EFFFFFFFFFFE00_00 +FFFFFF0000100020_43EFFFFFE0000200_01 +67F167FBC7FC5F9A_43D9FC59FEF1FF18_01 +FFFFFFFFFFF80000_43EFFFFFFFFFFF00_00 +003FFFFFFFFC0001_434FFFFFFFFE0000_01 +002E48F9F4EBD30E_4347247CFA75E987_00 +FFFFFFFFFFFC0000_43EFFFFFFFFFFF80_00 +DFFFFFFFFFFBFFFE_43EBFFFFFFFFFF80_01 +0091C23EE8C9424F_43623847DD19284A_01 +FFFFFFFFFFFE0000_43EFFFFFFFFFFFC0_00 +F7DFFBFFFFFFFFFE_43EEFBFF80000000_01 +00000000ACAE080C_41E595C101800000_00 +FFFFFFFFFFFF0000_43EFFFFFFFFFFFE0_00 +FFFFC00010000020_43EFFFF800020000_01 +0CD921F917B20E40_43A9B243F22F641C_01 +FFFFFFFFFFFF8000_43EFFFFFFFFFFFF0_00 +F8000FFFFFFFFFFD_43EF000200000000_01 +00017C566BC7D811_42F7C566BC7D8110_00 +FFFFFFFFFFFFC000_43EFFFFFFFFFFFF8_00 +00000000000000FE_406FC00000000000_00 +00F82AC14930D386_436F055829261A71_01 +FFFFFFFFFFFFE000_43EFFFFFFFFFFFFC_00 +00000000000003FC_408FE00000000000_00 +008E62EC60E119FC_4361CC5D8C1C2340_01 +FFFFFFFFFFFFF000_43EFFFFFFFFFFFFE_00 +FFFFEFF7FF7FFFFE_43EFFFFDFEFFF000_01 +1E2B1ECF210EEDC5_43BE2B1ECF210EEE_01 +FFFFFFFFFFFFF800_43EFFFFFFFFFFFFF_00 +00000000007FFF1F_415FFFC7C0000000_00 +000006534F5676F7_42994D3D59DBDC00_00 +FFFFFFFFFFFFFC00_43F0000000000000_01 +0000001004FFFFFD_423004FFFFFD0000_00 +0000435C939669F1_42D0D724E59A7C40_00 +FFFFFFFFFFFFFE00_43F0000000000000_01 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFE_01 +0000000000000011_4031000000000000_00 +FFFFFFFFFFFFFF00_43F0000000000000_01 +01FFFFFFFBFFEFFE_437FFFFFFFBFFF00_01 +000000000000036E_408B700000000000_00 +FFFFFFFFFFFFFF80_43F0000000000000_01 +FFF7FFFFFFFFF7FD_43EFFEFFFFFFFFFF_01 +000038E2BCFAC553_42CC715E7D62A980_00 +FFFFFFFFFFFFFFC0_43F0000000000000_01 +FFFFFBFFFFFE0FFE_43EFFFFF7FFFFFC2_01 +00000009A4E704BF_422349CE097E0000_00 +FFFFFFFFFFFFFFE0_43F0000000000000_01 +1400007FFFFFFFFD_43B4000080000000_01 +0000000093B187B4_41E27630F6800000_00 +FFFFFFFFFFFFFFF0_43F0000000000000_01 +40000000007FFFFD_43D0000000002000_01 +0000000000E7D468_416CFA8D00000000_00 +FFFFFFFFFFFFFFF8_43F0000000000000_01 +007FFEFFFFFBFFFE_435FFFBFFFFF0000_01 +000000026CEC79F8_42036763CFC00000_00 +FFFFFFFFFFFFFFFC_43F0000000000000_01 +00FFFFFF000000FF_436FFFFFE0000020_01 +0000000000D3983A_416A730740000000_00 +FFFFFFFFFFFFFFFE_43F0000000000000_01 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +00000001F4A7088A_41FF4A7088A00000_00 +FFFFFFFFFFFFFFFF_43F0000000000000_01 +000008000000027E_42A000000004FC00_00 +000000000001F4E8_40FF4E8000000000_00 +FFFFFFFFFFFFFFFD_43F0000000000000_01 +FFFFFFFFFF83FFDF_43EFFFFFFFFFF080_01 +00001E11407887B2_42BE11407887B200_00 +FFFFFFFFFFFFFFFB_43F0000000000000_01 +04000003FFFFFFF6_4390000010000000_01 +0000000000000D13_40AA260000000000_00 +FFFFFFFFFFFFFFF7_43F0000000000000_01 +BFFC00000000003E_43E7FF8000000000_01 +00000028D7BBB75B_42446BDDDBAD8000_00 +FFFFFFFFFFFFFFEF_43F0000000000000_01 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +0000000000CD5A23_4169AB4460000000_00 +FFFFFFFFFFFFFFDF_43F0000000000000_01 +FFBFDFFFBFFFFFFF_43EFF7FBFFF80000_01 +00000000000000FF_406FE00000000000_00 +FFFFFFFFFFFFFFBF_43F0000000000000_01 +00000007FF800003_421FFE00000C0000_00 +00000000000ABB02_4125760400000000_00 +FFFFFFFFFFFFFF7F_43F0000000000000_01 +FFFFFFFFFFFEE7FF_43EFFFFFFFFFFFDD_01 +00664B2B9BAD0DA2_435992CAE6EB4368_01 +FFFFFFFFFFFFFEFF_43F0000000000000_01 +0000000000100803_4130080300000000_00 +009B1DCB9F857D5E_436363B973F0AFAC_01 +FFFFFFFFFFFFFDFF_43F0000000000000_01 +FFFFFFBFFFFFEFEE_43EFFFFFF7FFFFFE_01 +36FD7542899C1C6F_43CB7EBAA144CE0E_01 +FFFFFFFFFFFFFBFF_43EFFFFFFFFFFFFF_01 +FF800000004001FF_43EFF00000000800_01 +0000000006BE4932_419AF924C8000000_00 +FFFFFFFFFFFFF7FF_43EFFFFFFFFFFFFF_01 +00001004000FFFFE_42B004000FFFFE00_00 +0000001DAA0123E0_423DAA0123E00000_00 +FFFFFFFFFFFFEFFF_43EFFFFFFFFFFFFE_01 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +00001C8703B1DCB0_42BC8703B1DCB000_00 +FFFFFFFFFFFFDFFF_43EFFFFFFFFFFFFC_01 +FE0FE00000000000_43EFC1FC00000000_00 +0F79ED944A4E2779_43AEF3DB28949C4F_01 +FFFFFFFFFFFFBFFF_43EFFFFFFFFFFFF8_01 +FBFFFE0400000000_43EF7FFFC0800000_00 +0000030127E03666_4288093F01B33000_00 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFF0_01 +FFFFF0200000FFFE_43EFFFFE04000020_01 +000000000000017F_4077F00000000000_00 +FFFFFFFFFFFEFFFF_43EFFFFFFFFFFFE0_01 +FFEFFE0000080000_43EFFDFFC0000100_00 +00000000013354EA_4173354EA0000000_00 +FFFFFFFFFFFDFFFF_43EFFFFFFFFFFFC0_01 +003FF0000003FFFE_434FF8000001FFFF_00 +0000016375B23F7B_4276375B23F7B000_00 +FFFFFFFFFFFBFFFF_43EFFFFFFFFFFF80_01 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000192117F38_41F92117F3800000_00 +FFFFFFFFFFF7FFFF_43EFFFFFFFFFFF00_01 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFF0_01 +00000000000018BE_40B8BE0000000000_00 +FFFFFFFFFFEFFFFF_43EFFFFFFFFFFE00_01 +004000020FFFFFFF_4350000084000000_01 +0000B84C2D8BC9CB_42E70985B1793960_00 +FFFFFFFFFFDFFFFF_43EFFFFFFFFFFC00_01 +00FFFFFFFFFFFFFD_4370000000000000_01 +00000223C2C6F284_42811E1637942000_00 +FFFFFFFFFFBFFFFF_43EFFFFFFFFFF800_01 +FFFDDFFFFFFFFFFD_43EFFFBC00000000_01 +00000000F46356C4_41EE8C6AD8800000_00 +FFFFFFFFFF7FFFFF_43EFFFFFFFFFF000_01 +010000000000BFFF_4370000000000C00_01 +0000000000000005_4014000000000000_00 +FFFFFFFFFEFFFFFF_43EFFFFFFFFFE000_01 +FFFFBF7FFBFFFFFE_43EFFFF7EFFF8000_01 +00000026386CE889_42431C3674448000_00 +FFFFFFFFFDFFFFFF_43EFFFFFFFFFC000_01 +F00000F7FFFFFFFF_43EE00001F000000_01 +0001FC53090C46A4_42FFC53090C46A40_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF8000_01 +0000000000800047_41600008E0000000_00 +000000001693872E_41B693872E000000_00 +FFFFFFFFF7FFFFFF_43EFFFFFFFFF0000_01 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000226A7845E35_4281353C22F1A800_00 +FFFFFFFFEFFFFFFF_43EFFFFFFFFE0000_01 +FFFFFFDFFFFFFBFD_43EFFFFFFBFFFFFF_01 +000000005433D14C_41D50CF453000000_00 +FFFFFFFFDFFFFFFF_43EFFFFFFFFC0000_01 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +00F23E8068D3D84A_436E47D00D1A7B09_01 +FFFFFFFFBFFFFFFF_43EFFFFFFFF80000_01 +F7FFBFFFFFFFBFFF_43EEFFF7FFFFFFF8_01 +0000BD29B7459087_42E7A536E8B210E0_00 +FFFFFFFF7FFFFFFF_43EFFFFFFFF00000_01 +FFFFFFF8FFFFBFFF_43EFFFFFFF1FFFF8_01 +00000000002DDC06_4146EE0300000000_00 +FFFFFFFEFFFFFFFF_43EFFFFFFFE00000_01 +FFFFFFF80001FFFF_43EFFFFFFF000040_01 +0000000000012FF9_40F2FF9000000000_00 +FFFFFFFDFFFFFFFF_43EFFFFFFFC00000_01 +004000040000FFFF_4350000100004000_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFBFFFFFFFF_43EFFFFFFF800000_01 +C0000000007FFFFA_43E8000000001000_01 +0000000006053E2B_419814F8AC000000_00 +FFFFFFF7FFFFFFFF_43EFFFFFFF000000_01 +7FFE000007FFFFFF_43DFFF8000020000_01 +000000000000002D_4046800000000000_00 +FFFFFFEFFFFFFFFF_43EFFFFFFE000000_01 +F80000000001007E_43EF000000000020_01 +00000D48424AD9D6_42AA908495B3AC00_00 +FFFFFFDFFFFFFFFF_43EFFFFFFC000000_01 +FFFFFE0001FEFFFF_43EFFFFFC0003FE0_01 +000000000000033B_4089D80000000000_00 +FFFFFFBFFFFFFFFF_43EFFFFFF8000000_01 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0243_01 +FFFFFF7FFFFFFFFF_43EFFFFFF0000000_01 +00FFF7FFFF7FFFFE_436FFEFFFFF00000_01 +0000000000000086_4060C00000000000_00 +FFFFFEFFFFFFFFFF_43EFFFFFE0000000_01 +FBFFFFBFFFBFFFFF_43EF7FFFF7FFF800_01 +00000000000021BA_40C0DD0000000000_00 +FFFFFDFFFFFFFFFF_43EFFFFFC0000000_01 +0000000040000082_41D0000020800000_00 +0007A2BF5B689F89_431E8AFD6DA27E24_00 +FFFFFBFFFFFFFFFF_43EFFFFF80000000_01 +0000001FF8000008_423FF80000080000_00 +387CAA7DE672DE8B_43CC3E553EF3396F_01 +FFFFF7FFFFFFFFFF_43EFFFFF00000000_01 +07FFF80000000002_439FFFE000000000_01 +0000000030A1E5B8_41C850F2DC000000_00 +FFFFEFFFFFFFFFFF_43EFFFFE00000000_01 +F7FFFFE00007FFFF_43EEFFFFFC000100_01 +000000000006ADFC_411AB7F000000000_00 +FFFFDFFFFFFFFFFF_43EFFFFC00000000_01 +FFFFFF03FFFFFFC0_43EFFFFFE0800000_01 +0A579475948F0032_43A4AF28EB291E00_01 +FFFFBFFFFFFFFFFF_43EFFFF800000000_01 +FC00000000003FF6_43EF800000000008_01 +00AE677AC313BF60_4365CCEF586277EC_00 +FFFF7FFFFFFFFFFF_43EFFFF000000000_01 +02000007FF7FFFFF_438000003FFC0000_01 +0000002E999639F1_42474CCB1CF88000_00 +FFFEFFFFFFFFFFFF_43EFFFE000000000_01 +FFFF83FFFFFFFFBE_43EFFFF080000000_01 +000000000003537D_410A9BE800000000_00 +FFFDFFFFFFFFFFFF_43EFFFC000000000_01 +EFFFFFC00000003D_43EDFFFFF8000000_01 +000000121FEDFD35_42321FEDFD350000_00 +FFFBFFFFFFFFFFFF_43EFFF8000000000_01 +FFFFFFF0000007FE_43EFFFFFFE000001_01 +00000000001E0839_413E083900000000_00 +FFF7FFFFFFFFFFFF_43EFFF0000000000_01 +0000007FFFE000FF_425FFFF8003FC000_00 +0000000079F30F48_41DE7CC3D2000000_00 +FFEFFFFFFFFFFFFF_43EFFE0000000000_01 +FFFFFC13FFFFFFFD_43EFFFFF82800000_01 +0000000000003B85_40CDC28000000000_00 +FFDFFFFFFFFFFFFF_43EFFC0000000000_01 +000008000007FFFE_42A000000FFFFC00_00 +32DB4409E5AE87E6_43C96DA204F2D744_01 +FFBFFFFFFFFFFFFF_43EFF80000000000_01 +FFFFFFFFFFF7BFEE_43EFFFFFFFFFFEF8_01 +000000000000003D_404E800000000000_00 +FF7FFFFFFFFFFFFF_43EFF00000000000_01 +000000001040FFFE_41B040FFFE000000_00 +00004909A09C13D3_42D242682704F4C0_00 +FEFFFFFFFFFFFFFF_43EFE00000000000_01 +FFFFFF01FFFFFF7F_43EFFFFFE0400000_01 +00000072E7D2575D_425CB9F495D74000_00 +FDFFFFFFFFFFFFFF_43EFC00000000000_01 +FFFFFFFFFFFEFFDB_43EFFFFFFFFFFFE0_01 +0000000000000057_4055C00000000000_00 +FBFFFFFFFFFFFFFF_43EF800000000000_01 +100000001FFFFFF6_43B0000000200000_01 +000000914B12EF51_426229625DEA2000_00 +F7FFFFFFFFFFFFFF_43EF000000000000_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFC_01 +000000769F3A5C2C_425DA7CE970B0000_00 +EFFFFFFFFFFFFFFF_43EE000000000000_01 +FFFFFFFDF7FFFFFD_43EFFFFFFFBF0000_01 +0000000000000002_4000000000000000_00 +DFFFFFFFFFFFFFFF_43EC000000000000_01 +FFFFFFFFFE0007FF_43EFFFFFFFFFC001_01 +000000000000009E_4063C00000000000_00 +BFFFFFFFFFFFFFFF_43E8000000000000_01 +FFF800000009FFFF_43EFFF0000000140_01 +0000000000087AA4_4120F54800000000_00 +7FFFFFFFFFFFFFFF_43E0000000000000_01 +4080000000FFFFFF_43D0200000004000_01 +000000001DE7601D_41BDE7601D000000_00 +3FFFFFFFFFFFFFFF_43D0000000000000_01 +FFCFFFFFFFBFFFFE_43EFF9FFFFFFF800_01 +000000000000004A_4052800000000000_00 +1FFFFFFFFFFFFFFF_43C0000000000000_01 +000080400000003F_42E00800000007E0_00 +00000000003F75A5_414FBAD280000000_00 +0FFFFFFFFFFFFFFF_43B0000000000000_01 +FFFFFFEFFFFFCFFE_43EFFFFFFDFFFFFA_01 +000000E775887420_426CEEB10E840000_00 +07FFFFFFFFFFFFFF_43A0000000000000_01 +00000000000801FE_412003FC00000000_00 +0000000000A13FF1_416427FE20000000_00 +03FFFFFFFFFFFFFF_4390000000000000_01 +07FEFFFFFFFFFFEE_439FFC0000000000_01 +000000000000000C_4028000000000000_00 +01FFFFFFFFFFFFFF_4380000000000000_01 +0000000820000003_4220400000060000_00 +00000001AD105214_41FAD10521400000_00 +00FFFFFFFFFFFFFF_4370000000000000_01 +FFFFF00FFFFFFFBE_43EFFFFE02000000_01 +0000000000CC48E7_4169891CE0000000_00 +007FFFFFFFFFFFFF_4360000000000000_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +00000000000BA6CB_41274D9600000000_00 +003FFFFFFFFFFFFF_4350000000000000_01 +FFFFFF7FBFFFFFBF_43EFFFFFEFF80000_01 +0000000000024425_4102212800000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFE00_01 +0000004E7115EC53_42539C457B14C000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_43EFFFFF00800000_01 +0000002E539ADCFE_424729CD6E7F0000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF8000_01 +000000D5084732F3_426AA108E65E6000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_43E7FFF000000000_01 +0000000000000543_40950C0000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +000000000000491B_40D246C000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_43EF800400000004_01 +0000016898822A24_4276898822A24000_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF8200000000_01 +0000000FFE18C7BF_422FFC318F7E0000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_43EFFFFFDFFFE000_01 +02F03620C1266ED9_438781B106093377_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_43E7EFE000000000_01 +0000000000000055_4055400000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_43EFFF7FFFFF0080_01 +0000000000168684_4136868400000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_43EBFFFFFC000000_01 +0000000000000CF5_40A9EA0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_43EFFFE008000020_01 +0000000000000022_4041000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_43EF7FFFFFFFFFF8_01 +0000000000001BC9_40BBC90000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_43E00FFFFFFFFFFC_01 +000274E35A70CD76_4303A71AD3866BB0_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFE0000_01 +0000000300E73AFC_42080739D7E00000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_43EFF80000000020_01 +00000000000615E9_411857A400000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +00000000000000B3_4066600000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +0000006E6B141E1B_425B9AC50786C000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_43EFFFFFFFFEC001_01 +00000003AB310BA6_420D59885D300000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +0000000000000195_4079500000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_43EFFFFFFFF00000_01 +00000059BA8D5559_42566EA355564000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_43EF7FE000000000_01 +000001B6F062822D_427B6F062822D000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +03CEAD9E2FB104A4_438E756CF17D8825_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +000000000D681E78_41AAD03CF0000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000058_4056000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000000_01 +0000000000000095_4062A00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000C00000000_01 +0000009697087B19_4262D2E10F632000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_43EF7FFFFFFFFDE0_01 +0000001E64BDFC55_423E64BDFC550000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_43EF800000004000_01 +0000D156A62AB849_42EA2AD4C5570920_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_43EFFFFFFF07FE00_01 +00035354EAE7C259_430A9AA7573E12C8_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_43F0000000000000_01 +00000000F4DF3C75_41EE9BE78EA00000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_43EFFF4000000004_01 +0000000000000003_4008000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_43EFFFFFFFFFF000_01 +0000005B5433CB9B_4256D50CF2E6C000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_43EFFFFFBFFBFFC0_01 +0000000000DEAE1F_416BD5C3E0000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_43EFFFFFFFFE0100_01 +000000007735DEC7_41DDCD77B1C00000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000007757D8B12ED_429DD5F62C4BB400_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_43EFFFFFC0FF0000_01 +00002A654064E046_42C532A032702300_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A0000000000030_01 +0000000000000007_401C000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF8_01 +00002D78B3D6C3B6_42C6BC59EB61DB00_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +000000070B77F34F_421C2DDFCD3C0000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_43EFFFFFF0000E00_01 +0000093EB4D67EC8_42A27D69ACFD9000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_43E7FFFBFFFF8000_01 +0205CEAF34EA1DC7_43802E7579A750EE_01 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +0000000000000003_4008000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000760D0_411D834000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_4370040000000000_01 +02C000708FF1BA51_43860003847F8DD3_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_43EF004000008000_01 +4F9E07DCC0BDC061_43D3E781F7302F70_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000008_01 +00000001B9B2A079_41FB9B2A07900000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_43EFFF0000000010_01 +00000000005EB5B4_4157AD6D00000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +0000000000DAC607_416B58C0E0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_43EFFFFFFFDF0000_01 +00000DC5B9D66984_42AB8B73ACD30800_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_43E8003FFFFFFE00_00 +00003D06B372AA06_42CE8359B9550300_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f64_ru.tv b/wally-pipelined/testbench/fp/ui64_f64_ru.tv new file mode 100644 index 000000000..9be55fa73 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f64_ru.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFE_01 +0000000072CC8B7A_41DCB322DE800000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_43EFFFFFFFF80008_01 +072C857F319EDE38_439CB215FCC67B79_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_43EFFFFF7FFFFF01_01 +00794C79B6D3007B_435E531E6DB4C01F_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_43EF7FFFFE000001_01 +0000000005AE458D_4196B91634000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +09EB456140D88764_43A3D68AC281B10F_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_43EFFFFC80200000_01 +27DE834A248EDF36_43C3EF41A5124770_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +00000000000385E2_410C2F1000000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_43EE008400000000_01 +000000159EB1FD45_42359EB1FD450000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_43EFFFFFFFFFFFA0_01 +000000000002DDFE_4106EFF000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000002C89FF56B_420644FFAB580000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +3B5E4F0BE0DEBFF0_43CDAF2785F06F60_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_43EFFFBF00800000_01 +000000000004766B_4111D9AC00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000002C_4046000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +07E662A109109D0A_439F998A84244275_01 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_43E8000000070000_01 +0000000000000064_4059000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_43EF002000000200_00 +02114B79075F70EE_43808A5BC83AFB88_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000101_01 +0000000000000BAC_40A7580000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +000000C4A3A3DBE5_426894747B7CA000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_43EFFC0007E00000_01 +0000000000001A91_40BA910000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_43EFFFFEF8800000_01 +0000000000007309_40DCC24000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +0000000000000F58_40AEB00000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_43EFFFFFFBC04000_01 +0000000000006980_40DA600000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +00000000000000DD_406BA00000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +00008C23DA2CEAD8_42E1847B459D5B00_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_43EC000000000800_01 +00000DE3C1DEC43C_42ABC783BD887800_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_43EFFFE000018000_01 +000000008030FFBE_41E0061FF7C00000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_43EFFFC00000FFFE_01 +000000000FDEED86_41AFBDDB0C000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_43EE7FFFFFFFF800_01 +000000005DA3FF45_41D768FFD1400000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_43EFFFFFFFE00021_01 +000000009B1BCB54_41E363796A800000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +027DD19DE6563714_4383EE8CEF32B1B9_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_43EFF80000000801_01 +000000000003A359_410D1AC800000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +000000003E62EC20_41CF317610000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000685F_40DA17C000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_43EFFFFFFFF7FFFF_01 +00000836F99DBAA8_42A06DF33B755000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0073466832042D47_435CD19A0C810B52_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_43F0000000000000_01 +00000000007829C8_415E0A7200000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000001FB77C672B_423FB77C672B0000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFC000000_01 +0000000000005B78_40D6DE0000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_43EFEFFFFFFFFDFC_01 +00000000000000F1_406E200000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +0000000000000006_4018000000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +0008A60D9E19F17E_43214C1B3C33E2FC_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +0000000007506DBA_419D41B6E8000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_43EFFFFFFFFFFFE0_01 +0000000006A42AC9_419A90AB24000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +0007AA3F2BDACC89_431EA8FCAF6B3224_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_43EFFF0080000080_00 +0000000000000005_4014000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_43EFFFF000010001_01 +000DF681DECDADC9_432BED03BD9B5B92_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_43EFFFFFDFFFFC01_01 +0000000000004FBE_40D3EF8000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +00C01FECA24DE1B0_436803FD9449BC36_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_43EEFFFFFFFBFFF0_01 +0058A66761669936_43562999D859A64E_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_43EFFFDFF0000001_01 +0716EA43FAC45C97_439C5BA90FEB1173_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_43F0000000000000_01 +0064D70EC7661FD8_435935C3B1D987F6_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_43E8100000000000_01 +00D956DBD0AEE817_436B2ADB7A15DD03_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F80000000_01 +0000000000004300_40D0C00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +012EDF40F41F6021_4372EDF40F41F603_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_43EFF20000000001_01 +000000383DE950F6_424C1EF4A87B0000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_43E000007FFFFF80_00 +002B59CB3A604D69_4345ACE59D3026B5_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFF0_01 +000001A37C210862_427A37C210862000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +0000365CD8617789_42CB2E6C30BBC480_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +000000000000101D_40B01D0000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B0000080000040_01 +000000001D098D19_41BD098D19000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFB0_01 +000016B3BD2C7BEF_42B6B3BD2C7BEF00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +00004E5ADDDAA4A8_42D396B776A92A00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +0000000000000721_409C840000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +0000000000648262_4159209880000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_43E8000400000000_01 +0000007353AC45D2_425CD4EB11748000_00 +8000000000000000_43E0000000000000_00 +FFFFFFFFFFE7EFFF_43EFFFFFFFFFFCFE_01 +0000000001A1202D_417A1202D0000000_00 +C000000000000000_43E8000000000000_00 +FFFFFFFFFFFF5F7F_43EFFFFFFFFFFFEC_01 +0000000000C0CA70_4168194E00000000_00 +E000000000000000_43EC000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000007B55D87D4_421ED5761F500000_00 +F000000000000000_43EE000000000000_00 +FF80000DFFFFFFFF_43EFF00001C00000_01 +000000090510FAEF_42220A21F5DE0000_00 +F800000000000000_43EF000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000001724A_40F724A000000000_00 +FC00000000000000_43EF800000000000_00 +FFFFFFDF80000002_43EFFFFFFBF00001_01 +00000000000000E4_406C800000000000_00 +FE00000000000000_43EFC00000000000_00 +FEFFFFFFFFF800FE_43EFDFFFFFFFFF01_01 +00000002C6222702_4206311138100000_00 +FF00000000000000_43EFE00000000000_00 +0000000408000002_4210200000080000_00 +000002E96DF1CB41_42874B6F8E5A0800_00 +FF80000000000000_43EFF00000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE80_01 +0727F174DEE7DC85_439C9FC5D37B9F73_01 +FFC0000000000000_43EFF80000000000_00 +8000000003FFFEFE_43E0000000008000_01 +000000000010BD5B_4130BD5B00000000_00 +FFE0000000000000_43EFFC0000000000_00 +0BEFFFFFFFFFFFFF_43A7E00000000000_01 +000000000022790C_41413C8600000000_00 +FFF0000000000000_43EFFE0000000000_00 +FFFFFFFFFFEFFBFA_43EFFFFFFFFFFE00_01 +000000369E75DF01_424B4F3AEF808000_00 +FFF8000000000000_43EFFF0000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000001E_403E000000000000_00 +FFFC000000000000_43EFFF8000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +0000000000328622_4149431100000000_00 +FFFE000000000000_43EFFFC000000000_00 +FFFFFF7FFFFDF7FF_43EFFFFFEFFFFFBF_01 +00172F0EC496FE21_43372F0EC496FE21_00 +FFFF000000000000_43EFFFE000000000_00 +DFBFFFFFFFFFFFFE_43EBF80000000000_01 +0000000004FC1FCA_4193F07F28000000_00 +FFFF800000000000_43EFFFF000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +000F5194E4A9C2CE_432EA329C953859C_00 +FFFFC00000000000_43EFFFF800000000_00 +00000002100007FD_420080003FE80000_00 +000000000002D8FE_4106C7F000000000_00 +FFFFE00000000000_43EFFFFC00000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000003766E_410BB37000000000_00 +FFFFF00000000000_43EFFFFE00000000_00 +0040000400000002_4350000100000001_01 +000000000000F841_40EF082000000000_00 +FFFFF80000000000_43EFFFFF00000000_00 +3DFFFFFFFFFFFF7E_43CF000000000000_01 +0000000549E17E30_42152785F8C00000_00 +FFFFFC0000000000_43EFFFFF80000000_00 +FFFFFFFFFFFFFEE1_43F0000000000000_01 +0000000000000027_4043800000000000_00 +FFFFFE0000000000_43EFFFFFC0000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +0000000000000373_408B980000000000_00 +FFFFFF0000000000_43EFFFFFE0000000_00 +FD00000008000000_43EFA00000010000_00 +000000000005DBB1_41176EC400000000_00 +FFFFFF8000000000_43EFFFFFF0000000_00 +FFFFFFFFFFF8007F_43EFFFFFFFFFFF01_01 +00000002FD10A515_4207E88528A80000_00 +FFFFFFC000000000_43EFFFFFF8000000_00 +FFEFFFFFFFFFFFFE_43EFFE0000000000_01 +0AB02984F6283B6C_43A5605309EC5077_01 +FFFFFFE000000000_43EFFFFFFC000000_00 +FFFFFFBC000001FE_43EFFFFFF7800001_01 +00B087C6B9FE7FE0_436610F8D73FCFFC_00 +FFFFFFF000000000_43EFFFFFFE000000_00 +FFF80001000007FE_43EFFF0000200001_01 +01F2762EA6837956_437F2762EA683796_01 +FFFFFFF800000000_43EFFFFFFF000000_00 +FFF7E0FFFFFFFFFE_43EFFEFC20000000_01 +00022E1175484626_4301708BAA423130_00 +FFFFFFFC00000000_43EFFFFFFF800000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000168F_40B68F0000000000_00 +FFFFFFFE00000000_43EFFFFFFFC00000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFE000_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFF00000000_43EFFFFFFFE00000_00 +FFFFFFD0000FFFFD_43EFFFFFFA000200_01 +000001BDF6658B83_427BDF6658B83000_00 +FFFFFFFF80000000_43EFFFFFFFF00000_00 +1000001FFDFFFFFF_43B000001FFE0000_01 +000000000000BB5B_40E76B6000000000_00 +FFFFFFFFC0000000_43EFFFFFFFF80000_00 +FFFFFFBFFE0FFFFF_43EFFFFFF7FFC200_01 +0000000000000000_0000000000000000_00 +FFFFFFFFE0000000_43EFFFFFFFFC0000_00 +FFFFFFFBF00007FF_43EFFFFFFF7E0001_01 +01E986274F48EAAD_437E986274F48EAB_01 +FFFFFFFFF0000000_43EFFFFFFFFE0000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFE000000_01 +000000000000CB5A_40E96B4000000000_00 +FFFFFFFFF8000000_43EFFFFFFFFF0000_00 +7FF000000000FFFF_43DFFC0000000040_01 +0000000BC2717FC3_422784E2FF860000_00 +FFFFFFFFFC000000_43EFFFFFFFFF8000_00 +FFFFFFE00008001F_43EFFFFFFC000101_01 +00000000000FABDA_412F57B400000000_00 +FFFFFFFFFE000000_43EFFFFFFFFFC000_00 +0200000000000002_4380000000000001_01 +0000000000FDA53F_416FB4A7E0000000_00 +FFFFFFFFFF000000_43EFFFFFFFFFE000_00 +F6000003FFFFFFFE_43EEC00000800000_01 +0000000000000010_4030000000000000_00 +FFFFFFFFFF800000_43EFFFFFFFFFF000_00 +FFFFFFFFFFBFFF7E_43EFFFFFFFFFF800_01 +00000001EE0FEA62_41FEE0FEA6200000_00 +FFFFFFFFFFC00000_43EFFFFFFFFFF800_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000077F35EDC1D_425DFCD7B7074000_00 +FFFFFFFFFFE00000_43EFFFFFFFFFFC00_00 +FFFFFFF7FDFFFF7D_43EFFFFFFEFFC000_01 +00000000000003AD_408D680000000000_00 +FFFFFFFFFFF00000_43EFFFFFFFFFFE00_00 +FFFFFF0000100020_43EFFFFFE0000201_01 +67F167FBC7FC5F9A_43D9FC59FEF1FF18_01 +FFFFFFFFFFF80000_43EFFFFFFFFFFF00_00 +003FFFFFFFFC0001_434FFFFFFFFE0001_01 +002E48F9F4EBD30E_4347247CFA75E987_00 +FFFFFFFFFFFC0000_43EFFFFFFFFFFF80_00 +DFFFFFFFFFFBFFFE_43EBFFFFFFFFFF80_01 +0091C23EE8C9424F_43623847DD19284A_01 +FFFFFFFFFFFE0000_43EFFFFFFFFFFFC0_00 +F7DFFBFFFFFFFFFE_43EEFBFF80000000_01 +00000000ACAE080C_41E595C101800000_00 +FFFFFFFFFFFF0000_43EFFFFFFFFFFFE0_00 +FFFFC00010000020_43EFFFF800020001_01 +0CD921F917B20E40_43A9B243F22F641D_01 +FFFFFFFFFFFF8000_43EFFFFFFFFFFFF0_00 +F8000FFFFFFFFFFD_43EF000200000000_01 +00017C566BC7D811_42F7C566BC7D8110_00 +FFFFFFFFFFFFC000_43EFFFFFFFFFFFF8_00 +00000000000000FE_406FC00000000000_00 +00F82AC14930D386_436F055829261A71_01 +FFFFFFFFFFFFE000_43EFFFFFFFFFFFFC_00 +00000000000003FC_408FE00000000000_00 +008E62EC60E119FC_4361CC5D8C1C2340_01 +FFFFFFFFFFFFF000_43EFFFFFFFFFFFFE_00 +FFFFEFF7FF7FFFFE_43EFFFFDFEFFF000_01 +1E2B1ECF210EEDC5_43BE2B1ECF210EEE_01 +FFFFFFFFFFFFF800_43EFFFFFFFFFFFFF_00 +00000000007FFF1F_415FFFC7C0000000_00 +000006534F5676F7_42994D3D59DBDC00_00 +FFFFFFFFFFFFFC00_43F0000000000000_01 +0000001004FFFFFD_423004FFFFFD0000_00 +0000435C939669F1_42D0D724E59A7C40_00 +FFFFFFFFFFFFFE00_43F0000000000000_01 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFE_01 +0000000000000011_4031000000000000_00 +FFFFFFFFFFFFFF00_43F0000000000000_01 +01FFFFFFFBFFEFFE_437FFFFFFFBFFF00_01 +000000000000036E_408B700000000000_00 +FFFFFFFFFFFFFF80_43F0000000000000_01 +FFF7FFFFFFFFF7FD_43EFFEFFFFFFFFFF_01 +000038E2BCFAC553_42CC715E7D62A980_00 +FFFFFFFFFFFFFFC0_43F0000000000000_01 +FFFFFBFFFFFE0FFE_43EFFFFF7FFFFFC2_01 +00000009A4E704BF_422349CE097E0000_00 +FFFFFFFFFFFFFFE0_43F0000000000000_01 +1400007FFFFFFFFD_43B4000080000000_01 +0000000093B187B4_41E27630F6800000_00 +FFFFFFFFFFFFFFF0_43F0000000000000_01 +40000000007FFFFD_43D0000000002000_01 +0000000000E7D468_416CFA8D00000000_00 +FFFFFFFFFFFFFFF8_43F0000000000000_01 +007FFEFFFFFBFFFE_435FFFBFFFFF0000_01 +000000026CEC79F8_42036763CFC00000_00 +FFFFFFFFFFFFFFFC_43F0000000000000_01 +00FFFFFF000000FF_436FFFFFE0000020_01 +0000000000D3983A_416A730740000000_00 +FFFFFFFFFFFFFFFE_43F0000000000000_01 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +00000001F4A7088A_41FF4A7088A00000_00 +FFFFFFFFFFFFFFFF_43F0000000000000_01 +000008000000027E_42A000000004FC00_00 +000000000001F4E8_40FF4E8000000000_00 +FFFFFFFFFFFFFFFD_43F0000000000000_01 +FFFFFFFFFF83FFDF_43EFFFFFFFFFF080_01 +00001E11407887B2_42BE11407887B200_00 +FFFFFFFFFFFFFFFB_43F0000000000000_01 +04000003FFFFFFF6_4390000010000000_01 +0000000000000D13_40AA260000000000_00 +FFFFFFFFFFFFFFF7_43F0000000000000_01 +BFFC00000000003E_43E7FF8000000001_01 +00000028D7BBB75B_42446BDDDBAD8000_00 +FFFFFFFFFFFFFFEF_43F0000000000000_01 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +0000000000CD5A23_4169AB4460000000_00 +FFFFFFFFFFFFFFDF_43F0000000000000_01 +FFBFDFFFBFFFFFFF_43EFF7FBFFF80000_01 +00000000000000FF_406FE00000000000_00 +FFFFFFFFFFFFFFBF_43F0000000000000_01 +00000007FF800003_421FFE00000C0000_00 +00000000000ABB02_4125760400000000_00 +FFFFFFFFFFFFFF7F_43F0000000000000_01 +FFFFFFFFFFFEE7FF_43EFFFFFFFFFFFDD_01 +00664B2B9BAD0DA2_435992CAE6EB4369_01 +FFFFFFFFFFFFFEFF_43F0000000000000_01 +0000000000100803_4130080300000000_00 +009B1DCB9F857D5E_436363B973F0AFAC_01 +FFFFFFFFFFFFFDFF_43F0000000000000_01 +FFFFFFBFFFFFEFEE_43EFFFFFF7FFFFFE_01 +36FD7542899C1C6F_43CB7EBAA144CE0F_01 +FFFFFFFFFFFFFBFF_43F0000000000000_01 +FF800000004001FF_43EFF00000000801_01 +0000000006BE4932_419AF924C8000000_00 +FFFFFFFFFFFFF7FF_43EFFFFFFFFFFFFF_01 +00001004000FFFFE_42B004000FFFFE00_00 +0000001DAA0123E0_423DAA0123E00000_00 +FFFFFFFFFFFFEFFF_43EFFFFFFFFFFFFE_01 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +00001C8703B1DCB0_42BC8703B1DCB000_00 +FFFFFFFFFFFFDFFF_43EFFFFFFFFFFFFC_01 +FE0FE00000000000_43EFC1FC00000000_00 +0F79ED944A4E2779_43AEF3DB28949C4F_01 +FFFFFFFFFFFFBFFF_43EFFFFFFFFFFFF8_01 +FBFFFE0400000000_43EF7FFFC0800000_00 +0000030127E03666_4288093F01B33000_00 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFF0_01 +FFFFF0200000FFFE_43EFFFFE04000020_01 +000000000000017F_4077F00000000000_00 +FFFFFFFFFFFEFFFF_43EFFFFFFFFFFFE0_01 +FFEFFE0000080000_43EFFDFFC0000100_00 +00000000013354EA_4173354EA0000000_00 +FFFFFFFFFFFDFFFF_43EFFFFFFFFFFFC0_01 +003FF0000003FFFE_434FF8000001FFFF_00 +0000016375B23F7B_4276375B23F7B000_00 +FFFFFFFFFFFBFFFF_43EFFFFFFFFFFF80_01 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000192117F38_41F92117F3800000_00 +FFFFFFFFFFF7FFFF_43EFFFFFFFFFFF00_01 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFF0_01 +00000000000018BE_40B8BE0000000000_00 +FFFFFFFFFFEFFFFF_43EFFFFFFFFFFE00_01 +004000020FFFFFFF_4350000084000000_01 +0000B84C2D8BC9CB_42E70985B1793960_00 +FFFFFFFFFFDFFFFF_43EFFFFFFFFFFC00_01 +00FFFFFFFFFFFFFD_4370000000000000_01 +00000223C2C6F284_42811E1637942000_00 +FFFFFFFFFFBFFFFF_43EFFFFFFFFFF800_01 +FFFDDFFFFFFFFFFD_43EFFFBC00000000_01 +00000000F46356C4_41EE8C6AD8800000_00 +FFFFFFFFFF7FFFFF_43EFFFFFFFFFF000_01 +010000000000BFFF_4370000000000C00_01 +0000000000000005_4014000000000000_00 +FFFFFFFFFEFFFFFF_43EFFFFFFFFFE000_01 +FFFFBF7FFBFFFFFE_43EFFFF7EFFF8000_01 +00000026386CE889_42431C3674448000_00 +FFFFFFFFFDFFFFFF_43EFFFFFFFFFC000_01 +F00000F7FFFFFFFF_43EE00001F000000_01 +0001FC53090C46A4_42FFC53090C46A40_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF8000_01 +0000000000800047_41600008E0000000_00 +000000001693872E_41B693872E000000_00 +FFFFFFFFF7FFFFFF_43EFFFFFFFFF0000_01 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000226A7845E35_4281353C22F1A800_00 +FFFFFFFFEFFFFFFF_43EFFFFFFFFE0000_01 +FFFFFFDFFFFFFBFD_43EFFFFFFC000000_01 +000000005433D14C_41D50CF453000000_00 +FFFFFFFFDFFFFFFF_43EFFFFFFFFC0000_01 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +00F23E8068D3D84A_436E47D00D1A7B0A_01 +FFFFFFFFBFFFFFFF_43EFFFFFFFF80000_01 +F7FFBFFFFFFFBFFF_43EEFFF7FFFFFFF8_01 +0000BD29B7459087_42E7A536E8B210E0_00 +FFFFFFFF7FFFFFFF_43EFFFFFFFF00000_01 +FFFFFFF8FFFFBFFF_43EFFFFFFF1FFFF8_01 +00000000002DDC06_4146EE0300000000_00 +FFFFFFFEFFFFFFFF_43EFFFFFFFE00000_01 +FFFFFFF80001FFFF_43EFFFFFFF000040_01 +0000000000012FF9_40F2FF9000000000_00 +FFFFFFFDFFFFFFFF_43EFFFFFFFC00000_01 +004000040000FFFF_4350000100004000_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFBFFFFFFFF_43EFFFFFFF800000_01 +C0000000007FFFFA_43E8000000001000_01 +0000000006053E2B_419814F8AC000000_00 +FFFFFFF7FFFFFFFF_43EFFFFFFF000000_01 +7FFE000007FFFFFF_43DFFF8000020000_01 +000000000000002D_4046800000000000_00 +FFFFFFEFFFFFFFFF_43EFFFFFFE000000_01 +F80000000001007E_43EF000000000021_01 +00000D48424AD9D6_42AA908495B3AC00_00 +FFFFFFDFFFFFFFFF_43EFFFFFFC000000_01 +FFFFFE0001FEFFFF_43EFFFFFC0003FE0_01 +000000000000033B_4089D80000000000_00 +FFFFFFBFFFFFFFFF_43EFFFFFF8000000_01 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0244_01 +FFFFFF7FFFFFFFFF_43EFFFFFF0000000_01 +00FFF7FFFF7FFFFE_436FFEFFFFF00000_01 +0000000000000086_4060C00000000000_00 +FFFFFEFFFFFFFFFF_43EFFFFFE0000000_01 +FBFFFFBFFFBFFFFF_43EF7FFFF7FFF800_01 +00000000000021BA_40C0DD0000000000_00 +FFFFFDFFFFFFFFFF_43EFFFFFC0000000_01 +0000000040000082_41D0000020800000_00 +0007A2BF5B689F89_431E8AFD6DA27E24_00 +FFFFFBFFFFFFFFFF_43EFFFFF80000000_01 +0000001FF8000008_423FF80000080000_00 +387CAA7DE672DE8B_43CC3E553EF33970_01 +FFFFF7FFFFFFFFFF_43EFFFFF00000000_01 +07FFF80000000002_439FFFE000000001_01 +0000000030A1E5B8_41C850F2DC000000_00 +FFFFEFFFFFFFFFFF_43EFFFFE00000000_01 +F7FFFFE00007FFFF_43EEFFFFFC000100_01 +000000000006ADFC_411AB7F000000000_00 +FFFFDFFFFFFFFFFF_43EFFFFC00000000_01 +FFFFFF03FFFFFFC0_43EFFFFFE0800000_01 +0A579475948F0032_43A4AF28EB291E01_01 +FFFFBFFFFFFFFFFF_43EFFFF800000000_01 +FC00000000003FF6_43EF800000000008_01 +00AE677AC313BF60_4365CCEF586277EC_00 +FFFF7FFFFFFFFFFF_43EFFFF000000000_01 +02000007FF7FFFFF_438000003FFC0000_01 +0000002E999639F1_42474CCB1CF88000_00 +FFFEFFFFFFFFFFFF_43EFFFE000000000_01 +FFFF83FFFFFFFFBE_43EFFFF080000000_01 +000000000003537D_410A9BE800000000_00 +FFFDFFFFFFFFFFFF_43EFFFC000000000_01 +EFFFFFC00000003D_43EDFFFFF8000001_01 +000000121FEDFD35_42321FEDFD350000_00 +FFFBFFFFFFFFFFFF_43EFFF8000000000_01 +FFFFFFF0000007FE_43EFFFFFFE000001_01 +00000000001E0839_413E083900000000_00 +FFF7FFFFFFFFFFFF_43EFFF0000000000_01 +0000007FFFE000FF_425FFFF8003FC000_00 +0000000079F30F48_41DE7CC3D2000000_00 +FFEFFFFFFFFFFFFF_43EFFE0000000000_01 +FFFFFC13FFFFFFFD_43EFFFFF82800000_01 +0000000000003B85_40CDC28000000000_00 +FFDFFFFFFFFFFFFF_43EFFC0000000000_01 +000008000007FFFE_42A000000FFFFC00_00 +32DB4409E5AE87E6_43C96DA204F2D744_01 +FFBFFFFFFFFFFFFF_43EFF80000000000_01 +FFFFFFFFFFF7BFEE_43EFFFFFFFFFFEF8_01 +000000000000003D_404E800000000000_00 +FF7FFFFFFFFFFFFF_43EFF00000000000_01 +000000001040FFFE_41B040FFFE000000_00 +00004909A09C13D3_42D242682704F4C0_00 +FEFFFFFFFFFFFFFF_43EFE00000000000_01 +FFFFFF01FFFFFF7F_43EFFFFFE0400000_01 +00000072E7D2575D_425CB9F495D74000_00 +FDFFFFFFFFFFFFFF_43EFC00000000000_01 +FFFFFFFFFFFEFFDB_43EFFFFFFFFFFFE0_01 +0000000000000057_4055C00000000000_00 +FBFFFFFFFFFFFFFF_43EF800000000000_01 +100000001FFFFFF6_43B0000000200000_01 +000000914B12EF51_426229625DEA2000_00 +F7FFFFFFFFFFFFFF_43EF000000000000_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFC_01 +000000769F3A5C2C_425DA7CE970B0000_00 +EFFFFFFFFFFFFFFF_43EE000000000000_01 +FFFFFFFDF7FFFFFD_43EFFFFFFFBF0000_01 +0000000000000002_4000000000000000_00 +DFFFFFFFFFFFFFFF_43EC000000000000_01 +FFFFFFFFFE0007FF_43EFFFFFFFFFC001_01 +000000000000009E_4063C00000000000_00 +BFFFFFFFFFFFFFFF_43E8000000000000_01 +FFF800000009FFFF_43EFFF0000000140_01 +0000000000087AA4_4120F54800000000_00 +7FFFFFFFFFFFFFFF_43E0000000000000_01 +4080000000FFFFFF_43D0200000004000_01 +000000001DE7601D_41BDE7601D000000_00 +3FFFFFFFFFFFFFFF_43D0000000000000_01 +FFCFFFFFFFBFFFFE_43EFF9FFFFFFF800_01 +000000000000004A_4052800000000000_00 +1FFFFFFFFFFFFFFF_43C0000000000000_01 +000080400000003F_42E00800000007E0_00 +00000000003F75A5_414FBAD280000000_00 +0FFFFFFFFFFFFFFF_43B0000000000000_01 +FFFFFFEFFFFFCFFE_43EFFFFFFDFFFFFA_01 +000000E775887420_426CEEB10E840000_00 +07FFFFFFFFFFFFFF_43A0000000000000_01 +00000000000801FE_412003FC00000000_00 +0000000000A13FF1_416427FE20000000_00 +03FFFFFFFFFFFFFF_4390000000000000_01 +07FEFFFFFFFFFFEE_439FFC0000000000_01 +000000000000000C_4028000000000000_00 +01FFFFFFFFFFFFFF_4380000000000000_01 +0000000820000003_4220400000060000_00 +00000001AD105214_41FAD10521400000_00 +00FFFFFFFFFFFFFF_4370000000000000_01 +FFFFF00FFFFFFFBE_43EFFFFE02000000_01 +0000000000CC48E7_4169891CE0000000_00 +007FFFFFFFFFFFFF_4360000000000000_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +00000000000BA6CB_41274D9600000000_00 +003FFFFFFFFFFFFF_4350000000000000_01 +FFFFFF7FBFFFFFBF_43EFFFFFEFF80000_01 +0000000000024425_4102212800000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFE00_01 +0000004E7115EC53_42539C457B14C000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_43EFFFFF00800000_01 +0000002E539ADCFE_424729CD6E7F0000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF8000_01 +000000D5084732F3_426AA108E65E6000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_43E7FFF000000000_01 +0000000000000543_40950C0000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +000000000000491B_40D246C000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_43EF800400000004_01 +0000016898822A24_4276898822A24000_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF8200000000_01 +0000000FFE18C7BF_422FFC318F7E0000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_43EFFFFFDFFFE000_01 +02F03620C1266ED9_438781B106093377_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_43E7EFE000000000_01 +0000000000000055_4055400000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_43EFFF7FFFFF0080_01 +0000000000168684_4136868400000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_43EBFFFFFC000001_01 +0000000000000CF5_40A9EA0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_43EFFFE008000020_01 +0000000000000022_4041000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_43EF7FFFFFFFFFF8_01 +0000000000001BC9_40BBC90000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_43E00FFFFFFFFFFC_01 +000274E35A70CD76_4303A71AD3866BB0_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFE0000_01 +0000000300E73AFC_42080739D7E00000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_43EFF80000000021_01 +00000000000615E9_411857A400000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +00000000000000B3_4066600000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +0000006E6B141E1B_425B9AC50786C000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_43EFFFFFFFFEC001_01 +00000003AB310BA6_420D59885D300000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +0000000000000195_4079500000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_43EFFFFFFFF00001_01 +00000059BA8D5559_42566EA355564000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_43EF7FE000000000_01 +000001B6F062822D_427B6F062822D000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +03CEAD9E2FB104A4_438E756CF17D8826_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +000000000D681E78_41AAD03CF0000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000058_4056000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000001_01 +0000000000000095_4062A00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000C00000000_01 +0000009697087B19_4262D2E10F632000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_43EF7FFFFFFFFDE0_01 +0000001E64BDFC55_423E64BDFC550000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_43EF800000004000_01 +0000D156A62AB849_42EA2AD4C5570920_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_43EFFFFFFF07FE00_01 +00035354EAE7C259_430A9AA7573E12C8_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_43F0000000000000_01 +00000000F4DF3C75_41EE9BE78EA00000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_43EFFF4000000004_01 +0000000000000003_4008000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_43EFFFFFFFFFF000_01 +0000005B5433CB9B_4256D50CF2E6C000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_43EFFFFFBFFBFFC0_01 +0000000000DEAE1F_416BD5C3E0000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_43EFFFFFFFFE0101_01 +000000007735DEC7_41DDCD77B1C00000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000007757D8B12ED_429DD5F62C4BB400_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_43EFFFFFC0FF0000_01 +00002A654064E046_42C532A032702300_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A0000000000030_01 +0000000000000007_401C000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF8_01 +00002D78B3D6C3B6_42C6BC59EB61DB00_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +000000070B77F34F_421C2DDFCD3C0000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_43EFFFFFF0000E00_01 +0000093EB4D67EC8_42A27D69ACFD9000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_43E7FFFBFFFF8000_01 +0205CEAF34EA1DC7_43802E7579A750EF_01 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +0000000000000003_4008000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000760D0_411D834000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_4370040000000000_01 +02C000708FF1BA51_43860003847F8DD3_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_43EF004000008000_01 +4F9E07DCC0BDC061_43D3E781F7302F71_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000008_01 +00000001B9B2A079_41FB9B2A07900000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_43EFFF0000000011_01 +00000000005EB5B4_4157AD6D00000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +0000000000DAC607_416B58C0E0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_43EFFFFFFFDF0001_01 +00000DC5B9D66984_42AB8B73ACD30800_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_43E8003FFFFFFE00_00 +00003D06B372AA06_42CE8359B9550300_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/ui64_f64_rz.tv b/wally-pipelined/testbench/fp/ui64_f64_rz.tv new file mode 100644 index 000000000..857916e80 --- /dev/null +++ b/wally-pipelined/testbench/fp/ui64_f64_rz.tv @@ -0,0 +1,756 @@ +07FFFDFFFFFFFF7F_439FFFF7FFFFFFFD_01 +0000000072CC8B7A_41DCB322DE800000_00 +0000000000000000_0000000000000000_00 +FFFFFFFFC0003FFE_43EFFFFFFFF80007_01 +072C857F319EDE38_439CB215FCC67B78_01 +0000000000000001_3FF0000000000000_00 +FFFFFBFFFFF8003E_43EFFFFF7FFFFF00_01 +00794C79B6D3007B_435E531E6DB4C01E_01 +0000000000000002_4000000000000000_00 +FBFFFFF0000001FF_43EF7FFFFE000000_01 +0000000005AE458D_4196B91634000000_00 +0000000000000004_4010000000000000_00 +00040008000007FE_4310002000001FF8_00 +09EB456140D88764_43A3D68AC281B10E_01 +0000000000000008_4020000000000000_00 +FFFFE400FFFFFFFE_43EFFFFC801FFFFF_01 +27DE834A248EDF36_43C3EF41A512476F_01 +0000000000000010_4030000000000000_00 +00000003FF001FFF_420FF800FFF80000_00 +00000000000385E2_410C2F1000000000_00 +0000000000000020_4040000000000000_00 +F0041FFFFFFFFFFF_43EE0083FFFFFFFF_01 +000000159EB1FD45_42359EB1FD450000_00 +0000000000000040_4050000000000000_00 +FFFFFFFFFFFCFFF9_43EFFFFFFFFFFF9F_01 +000000000002DDFE_4106EFF000000000_00 +0000000000000080_4060000000000000_00 +000000000003FF00_410FF80000000000_00 +00000002C89FF56B_420644FFAB580000_00 +0000000000000100_4070000000000000_00 +000FFFFF7FDFFFFF_432FFFFEFFBFFFFE_00 +3B5E4F0BE0DEBFF0_43CDAF2785F06F5F_01 +0000000000000200_4080000000000000_00 +FFFDF803FFFFFFFF_43EFFFBF007FFFFF_01 +000000000004766B_4111D9AC00000000_00 +0000000000000400_4090000000000000_00 +0000080100000FFE_42A00200001FFC00_00 +000000000000002C_4046000000000000_00 +0000000000000800_40A0000000000000_00 +0048000000100000_4352000000040000_00 +07E662A109109D0A_439F998A84244274_01 +0000000000001000_40B0000000000000_00 +C000000037FFFFFE_43E800000006FFFF_01 +0000000000000064_4059000000000000_00 +0000000000002000_40C0000000000000_00 +F801000000100000_43EF002000000200_00 +02114B79075F70EE_43808A5BC83AFB87_01 +0000000000004000_40D0000000000000_00 +100000000001003E_43B0000000000100_01 +0000000000000BAC_40A7580000000000_00 +0000000000008000_40E0000000000000_00 +200000FFFFFFF800_43C000007FFFFFFC_00 +000000C4A3A3DBE5_426894747B7CA000_00 +0000000000010000_40F0000000000000_00 +FFE0003EFFFFFFFF_43EFFC0007DFFFFF_01 +0000000000001A91_40BA910000000000_00 +0000000000020000_4100000000000000_00 +FFFFF7C3FFFFFFFD_43EFFFFEF87FFFFF_01 +0000000000007309_40DCC24000000000_00 +0000000000040000_4110000000000000_00 +000083FFF7FFFFFE_42E07FFEFFFFFFC0_00 +0000000000000F58_40AEB00000000000_00 +0000000000080000_4120000000000000_00 +FFFFFFDE01FFFFFE_43EFFFFFFBC03FFF_01 +0000000000006980_40DA600000000000_00 +0000000000100000_4130000000000000_00 +00000000FFF07FFF_41EFFE0FFFE00000_00 +00000000000000DD_406BA00000000000_00 +0000000000200000_4140000000000000_00 +000020FFDFFFFFFF_42C07FEFFFFFFF80_00 +00008C23DA2CEAD8_42E1847B459D5B00_00 +0000000000400000_4150000000000000_00 +E0000000003FFFDF_43EC0000000007FF_01 +00000DE3C1DEC43C_42ABC783BD887800_00 +0000000000800000_4160000000000000_00 +FFFF00000BFFFFFD_43EFFFE000017FFF_01 +000000008030FFBE_41E0061FF7C00000_00 +0000000001000000_4170000000000000_00 +FFFE000007FFEFFD_43EFFFC00000FFFD_01 +000000000FDEED86_41AFBDDB0C000000_00 +0000000002000000_4180000000000000_00 +F3FFFFFFFFBFFFFE_43EE7FFFFFFFF7FF_01 +000000005DA3FF45_41D768FFD1400000_00 +0000000004000000_4190000000000000_00 +FFFFFFFF00010007_43EFFFFFFFE00020_01 +000000009B1BCB54_41E363796A800000_00 +0000000008000000_41A0000000000000_00 +00004000004001FE_42D0000010007F80_00 +027DD19DE6563714_4383EE8CEF32B1B8_01 +0000000010000000_41B0000000000000_00 +FFC00000004007FE_43EFF80000000800_01 +000000000003A359_410D1AC800000000_00 +0000000020000000_41C0000000000000_00 +0000000003C000FE_418E0007F0000000_00 +000000003E62EC20_41CF317610000000_00 +0000000040000000_41D0000000000000_00 +000000003FFFFFFD_41CFFFFFFE800000_00 +000000000000685F_40DA17C000000000_00 +0000000080000000_41E0000000000000_00 +FFFFFFFFBFFFF00F_43EFFFFFFFF7FFFE_01 +00000836F99DBAA8_42A06DF33B755000_00 +0000000100000000_41F0000000000000_00 +00000020003FFEFE_4240001FFF7F0000_00 +0073466832042D47_435CD19A0C810B51_01 +0000000200000000_4200000000000000_00 +FFFFFFFFFFFFF887_43EFFFFFFFFFFFFF_01 +00000000007829C8_415E0A7200000000_00 +0000000400000000_4210000000000000_00 +00000FFFFFFF7DFD_42AFFFFFFEFBFA00_00 +0000001FB77C672B_423FB77C672B0000_00 +0000000800000000_4220000000000000_00 +08003FFDFFFFFFFE_43A0007FFBFFFFFF_01 +0000000000005B78_40D6DE0000000000_00 +0000001000000000_4230000000000000_00 +FF7FFFFFFFEFDFFF_43EFEFFFFFFFFDFB_01 +00000000000000F1_406E200000000000_00 +0000002000000000_4240000000000000_00 +000013FFFFFFFDFF_42B3FFFFFFFDFF00_00 +0000000000000006_4018000000000000_00 +0000004000000000_4250000000000000_00 +0800000000040800_43A0000000000810_00 +0008A60D9E19F17E_43214C1B3C33E2FC_00 +0000008000000000_4260000000000000_00 +000077FFF0000000_42DDFFFC00000000_00 +0000000007506DBA_419D41B6E8000000_00 +0000010000000000_4270000000000000_00 +FFFFFFFFFFFEFBF7_43EFFFFFFFFFFFDF_01 +0000000006A42AC9_419A90AB24000000_00 +0000020000000000_4280000000000000_00 +0000107FFFFFDFFD_42B07FFFFFDFFD00_00 +0007AA3F2BDACC89_431EA8FCAF6B3224_00 +0000040000000000_4290000000000000_00 +FFF8040000040000_43EFFF0080000080_00 +0000000000000005_4014000000000000_00 +0000080000000000_42A0000000000000_00 +FFFF80000800001F_43EFFFF000010000_01 +000DF681DECDADC9_432BED03BD9B5B92_00 +0000100000000000_42B0000000000000_00 +FFFFFEFFFFE0007F_43EFFFFFDFFFFC00_01 +0000000000004FBE_40D3EF8000000000_00 +0000200000000000_42C0000000000000_00 +0000000901FFFFFD_422203FFFFFA0000_00 +00C01FECA24DE1B0_436803FD9449BC36_00 +0000400000000000_42D0000000000000_00 +F7FFFFFFDFFF7FFF_43EEFFFFFFFBFFEF_01 +0058A66761669936_43562999D859A64D_01 +0000800000000000_42E0000000000000_00 +FFFEFF800000003E_43EFFFDFF0000000_01 +0716EA43FAC45C97_439C5BA90FEB1172_01 +0001000000000000_42F0000000000000_00 +FFFFFFFFFFFFFFC6_43EFFFFFFFFFFFFF_01 +0064D70EC7661FD8_435935C3B1D987F6_00 +0002000000000000_4300000000000000_00 +C07FFFFFFFFFFFFE_43E80FFFFFFFFFFF_01 +00D956DBD0AEE817_436B2ADB7A15DD02_01 +0004000000000000_4310000000000000_00 +020003EFFFFFFFFE_4380001F7FFFFFFF_01 +0000000000004300_40D0C00000000000_00 +0008000000000000_4320000000000000_00 +4000000004002000_43D0000000010008_00 +012EDF40F41F6021_4372EDF40F41F602_01 +0010000000000000_4330000000000000_00 +FF9000000000001D_43EFF20000000000_01 +000000383DE950F6_424C1EF4A87B0000_00 +0020000000000000_4340000000000000_00 +800003FFFFFC0000_43E000007FFFFF80_00 +002B59CB3A604D69_4345ACE59D3026B4_01 +0040000000000000_4350000000000000_00 +7FFFFFFDFFFFBFFF_43DFFFFFFF7FFFEF_01 +000001A37C210862_427A37C210862000_00 +0080000000000000_4360000000000000_00 +0002000002000002_4300000010000010_00 +0000365CD8617789_42CB2E6C30BBC480_00 +0100000000000000_4370000000000000_00 +00001BFFFFFFBFFE_42BBFFFFFFBFFE00_00 +000000000000101D_40B01D0000000000_00 +0200000000000000_4380000000000000_00 +1000008000003FFF_43B000008000003F_01 +000000001D098D19_41BD098D19000000_00 +0400000000000000_4390000000000000_00 +03FFFFFFFFFFF5FF_438FFFFFFFFFFFAF_01 +000016B3BD2C7BEF_42B6B3BD2C7BEF00_00 +0800000000000000_43A0000000000000_00 +00003FFFBFFFFFFE_42CFFFDFFFFFFF00_00 +00004E5ADDDAA4A8_42D396B776A92A00_00 +1000000000000000_43B0000000000000_00 +001FFFC000000FFD_433FFFC000000FFD_00 +0000000000000721_409C840000000000_00 +2000000000000000_43C0000000000000_00 +0000000041DFFFFF_41D077FFFFC00000_00 +0000000000648262_4159209880000000_00 +4000000000000000_43D0000000000000_00 +C0001FFFFFFFFFFB_43E80003FFFFFFFF_01 +0000007353AC45D2_425CD4EB11748000_00 +8000000000000000_43E0000000000000_00 +FFFFFFFFFFE7EFFF_43EFFFFFFFFFFCFD_01 +0000000001A1202D_417A1202D0000000_00 +C000000000000000_43E8000000000000_00 +FFFFFFFFFFFF5F7F_43EFFFFFFFFFFFEB_01 +0000000000C0CA70_4168194E00000000_00 +E000000000000000_43EC000000000000_00 +0000200201FFFFFE_42C00100FFFFFF00_00 +00000007B55D87D4_421ED5761F500000_00 +F000000000000000_43EE000000000000_00 +FF80000DFFFFFFFF_43EFF00001BFFFFF_01 +000000090510FAEF_42220A21F5DE0000_00 +F800000000000000_43EF000000000000_00 +0003FFF00000000F_430FFF8000000078_00 +000000000001724A_40F724A000000000_00 +FC00000000000000_43EF800000000000_00 +FFFFFFDF80000002_43EFFFFFFBF00000_01 +00000000000000E4_406C800000000000_00 +FE00000000000000_43EFC00000000000_00 +FEFFFFFFFFF800FE_43EFDFFFFFFFFF00_01 +00000002C6222702_4206311138100000_00 +FF00000000000000_43EFE00000000000_00 +0000000408000002_4210200000080000_00 +000002E96DF1CB41_42874B6F8E5A0800_00 +FF80000000000000_43EFF00000000000_00 +007FFFFFFFFFF9FE_435FFFFFFFFFFE7F_01 +0727F174DEE7DC85_439C9FC5D37B9F72_01 +FFC0000000000000_43EFF80000000000_00 +8000000003FFFEFE_43E0000000007FFF_01 +000000000010BD5B_4130BD5B00000000_00 +FFE0000000000000_43EFFC0000000000_00 +0BEFFFFFFFFFFFFF_43A7DFFFFFFFFFFF_01 +000000000022790C_41413C8600000000_00 +FFF0000000000000_43EFFE0000000000_00 +FFFFFFFFFFEFFBFA_43EFFFFFFFFFFDFF_01 +000000369E75DF01_424B4F3AEF808000_00 +FFF8000000000000_43EFFF0000000000_00 +00000007FEFFDFFF_421FFBFF7FFC0000_00 +000000000000001E_403E000000000000_00 +FFFC000000000000_43EFFF8000000000_00 +0003FFFE0007FFFE_430FFFF0003FFFF0_00 +0000000000328622_4149431100000000_00 +FFFE000000000000_43EFFFC000000000_00 +FFFFFF7FFFFDF7FF_43EFFFFFEFFFFFBE_01 +00172F0EC496FE21_43372F0EC496FE21_00 +FFFF000000000000_43EFFFE000000000_00 +DFBFFFFFFFFFFFFE_43EBF7FFFFFFFFFF_01 +0000000004FC1FCA_4193F07F28000000_00 +FFFF800000000000_43EFFFF000000000_00 +00000FFF800FFFFE_42AFFF001FFFFC00_00 +000F5194E4A9C2CE_432EA329C953859C_00 +FFFFC00000000000_43EFFFF800000000_00 +00000002100007FD_420080003FE80000_00 +000000000002D8FE_4106C7F000000000_00 +FFFFE00000000000_43EFFFFC00000000_00 +000000000007FF6E_411FFDB800000000_00 +000000000003766E_410BB37000000000_00 +FFFFF00000000000_43EFFFFE00000000_00 +0040000400000002_4350000100000000_01 +000000000000F841_40EF082000000000_00 +FFFFF80000000000_43EFFFFF00000000_00 +3DFFFFFFFFFFFF7E_43CEFFFFFFFFFFFF_01 +0000000549E17E30_42152785F8C00000_00 +FFFFFC0000000000_43EFFFFF80000000_00 +FFFFFFFFFFFFFEE1_43EFFFFFFFFFFFFF_01 +0000000000000027_4043800000000000_00 +FFFFFE0000000000_43EFFFFFC0000000_00 +000000000EFFFFDF_41ADFFFFBE000000_00 +0000000000000373_408B980000000000_00 +FFFFFF0000000000_43EFFFFFE0000000_00 +FD00000008000000_43EFA00000010000_00 +000000000005DBB1_41176EC400000000_00 +FFFFFF8000000000_43EFFFFFF0000000_00 +FFFFFFFFFFF8007F_43EFFFFFFFFFFF00_01 +00000002FD10A515_4207E88528A80000_00 +FFFFFFC000000000_43EFFFFFF8000000_00 +FFEFFFFFFFFFFFFE_43EFFDFFFFFFFFFF_01 +0AB02984F6283B6C_43A5605309EC5076_01 +FFFFFFE000000000_43EFFFFFFC000000_00 +FFFFFFBC000001FE_43EFFFFFF7800000_01 +00B087C6B9FE7FE0_436610F8D73FCFFC_00 +FFFFFFF000000000_43EFFFFFFE000000_00 +FFF80001000007FE_43EFFF0000200000_01 +01F2762EA6837956_437F2762EA683795_01 +FFFFFFF800000000_43EFFFFFFF000000_00 +FFF7E0FFFFFFFFFE_43EFFEFC1FFFFFFF_01 +00022E1175484626_4301708BAA423130_00 +FFFFFFFC00000000_43EFFFFFFF800000_00 +0000200020000FFE_42C000100007FF00_00 +000000000000168F_40B68F0000000000_00 +FFFFFFFE00000000_43EFFFFFFFC00000_00 +021FFFFFFFFBFFFF_4380FFFFFFFFDFFF_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFF00000000_43EFFFFFFFE00000_00 +FFFFFFD0000FFFFD_43EFFFFFFA0001FF_01 +000001BDF6658B83_427BDF6658B83000_00 +FFFFFFFF80000000_43EFFFFFFFF00000_00 +1000001FFDFFFFFF_43B000001FFDFFFF_01 +000000000000BB5B_40E76B6000000000_00 +FFFFFFFFC0000000_43EFFFFFFFF80000_00 +FFFFFFBFFE0FFFFF_43EFFFFFF7FFC1FF_01 +0000000000000000_0000000000000000_00 +FFFFFFFFE0000000_43EFFFFFFFFC0000_00 +FFFFFFFBF00007FF_43EFFFFFFF7E0000_01 +01E986274F48EAAD_437E986274F48EAA_01 +FFFFFFFFF0000000_43EFFFFFFFFE0000_00 +1FFFFFFDFFFFFF7F_43BFFFFFFDFFFFFF_01 +000000000000CB5A_40E96B4000000000_00 +FFFFFFFFF8000000_43EFFFFFFFFF0000_00 +7FF000000000FFFF_43DFFC000000003F_01 +0000000BC2717FC3_422784E2FF860000_00 +FFFFFFFFFC000000_43EFFFFFFFFF8000_00 +FFFFFFE00008001F_43EFFFFFFC000100_01 +00000000000FABDA_412F57B400000000_00 +FFFFFFFFFE000000_43EFFFFFFFFFC000_00 +0200000000000002_4380000000000000_01 +0000000000FDA53F_416FB4A7E0000000_00 +FFFFFFFFFF000000_43EFFFFFFFFFE000_00 +F6000003FFFFFFFE_43EEC000007FFFFF_01 +0000000000000010_4030000000000000_00 +FFFFFFFFFF800000_43EFFFFFFFFFF000_00 +FFFFFFFFFFBFFF7E_43EFFFFFFFFFF7FF_01 +00000001EE0FEA62_41FEE0FEA6200000_00 +FFFFFFFFFFC00000_43EFFFFFFFFFF800_00 +0000007FFF9FFFFD_425FFFE7FFFF4000_00 +00000077F35EDC1D_425DFCD7B7074000_00 +FFFFFFFFFFE00000_43EFFFFFFFFFFC00_00 +FFFFFFF7FDFFFF7D_43EFFFFFFEFFBFFF_01 +00000000000003AD_408D680000000000_00 +FFFFFFFFFFF00000_43EFFFFFFFFFFE00_00 +FFFFFF0000100020_43EFFFFFE0000200_01 +67F167FBC7FC5F9A_43D9FC59FEF1FF17_01 +FFFFFFFFFFF80000_43EFFFFFFFFFFF00_00 +003FFFFFFFFC0001_434FFFFFFFFE0000_01 +002E48F9F4EBD30E_4347247CFA75E987_00 +FFFFFFFFFFFC0000_43EFFFFFFFFFFF80_00 +DFFFFFFFFFFBFFFE_43EBFFFFFFFFFF7F_01 +0091C23EE8C9424F_43623847DD192849_01 +FFFFFFFFFFFE0000_43EFFFFFFFFFFFC0_00 +F7DFFBFFFFFFFFFE_43EEFBFF7FFFFFFF_01 +00000000ACAE080C_41E595C101800000_00 +FFFFFFFFFFFF0000_43EFFFFFFFFFFFE0_00 +FFFFC00010000020_43EFFFF800020000_01 +0CD921F917B20E40_43A9B243F22F641C_01 +FFFFFFFFFFFF8000_43EFFFFFFFFFFFF0_00 +F8000FFFFFFFFFFD_43EF0001FFFFFFFF_01 +00017C566BC7D811_42F7C566BC7D8110_00 +FFFFFFFFFFFFC000_43EFFFFFFFFFFFF8_00 +00000000000000FE_406FC00000000000_00 +00F82AC14930D386_436F055829261A70_01 +FFFFFFFFFFFFE000_43EFFFFFFFFFFFFC_00 +00000000000003FC_408FE00000000000_00 +008E62EC60E119FC_4361CC5D8C1C233F_01 +FFFFFFFFFFFFF000_43EFFFFFFFFFFFFE_00 +FFFFEFF7FF7FFFFE_43EFFFFDFEFFEFFF_01 +1E2B1ECF210EEDC5_43BE2B1ECF210EED_01 +FFFFFFFFFFFFF800_43EFFFFFFFFFFFFF_00 +00000000007FFF1F_415FFFC7C0000000_00 +000006534F5676F7_42994D3D59DBDC00_00 +FFFFFFFFFFFFFC00_43EFFFFFFFFFFFFF_01 +0000001004FFFFFD_423004FFFFFD0000_00 +0000435C939669F1_42D0D724E59A7C40_00 +FFFFFFFFFFFFFE00_43EFFFFFFFFFFFFF_01 +1FFFFFFFFFFFFDFD_43BFFFFFFFFFFFFD_01 +0000000000000011_4031000000000000_00 +FFFFFFFFFFFFFF00_43EFFFFFFFFFFFFF_01 +01FFFFFFFBFFEFFE_437FFFFFFFBFFEFF_01 +000000000000036E_408B700000000000_00 +FFFFFFFFFFFFFF80_43EFFFFFFFFFFFFF_01 +FFF7FFFFFFFFF7FD_43EFFEFFFFFFFFFE_01 +000038E2BCFAC553_42CC715E7D62A980_00 +FFFFFFFFFFFFFFC0_43EFFFFFFFFFFFFF_01 +FFFFFBFFFFFE0FFE_43EFFFFF7FFFFFC1_01 +00000009A4E704BF_422349CE097E0000_00 +FFFFFFFFFFFFFFE0_43EFFFFFFFFFFFFF_01 +1400007FFFFFFFFD_43B400007FFFFFFF_01 +0000000093B187B4_41E27630F6800000_00 +FFFFFFFFFFFFFFF0_43EFFFFFFFFFFFFF_01 +40000000007FFFFD_43D0000000001FFF_01 +0000000000E7D468_416CFA8D00000000_00 +FFFFFFFFFFFFFFF8_43EFFFFFFFFFFFFF_01 +007FFEFFFFFBFFFE_435FFFBFFFFEFFFF_01 +000000026CEC79F8_42036763CFC00000_00 +FFFFFFFFFFFFFFFC_43EFFFFFFFFFFFFF_01 +00FFFFFF000000FF_436FFFFFE000001F_01 +0000000000D3983A_416A730740000000_00 +FFFFFFFFFFFFFFFE_43EFFFFFFFFFFFFF_01 +00007FFFBFFF7FFE_42DFFFEFFFDFFF80_00 +00000001F4A7088A_41FF4A7088A00000_00 +FFFFFFFFFFFFFFFF_43EFFFFFFFFFFFFF_01 +000008000000027E_42A000000004FC00_00 +000000000001F4E8_40FF4E8000000000_00 +FFFFFFFFFFFFFFFD_43EFFFFFFFFFFFFF_01 +FFFFFFFFFF83FFDF_43EFFFFFFFFFF07F_01 +00001E11407887B2_42BE11407887B200_00 +FFFFFFFFFFFFFFFB_43EFFFFFFFFFFFFF_01 +04000003FFFFFFF6_439000000FFFFFFF_01 +0000000000000D13_40AA260000000000_00 +FFFFFFFFFFFFFFF7_43EFFFFFFFFFFFFF_01 +BFFC00000000003E_43E7FF8000000000_01 +00000028D7BBB75B_42446BDDDBAD8000_00 +FFFFFFFFFFFFFFEF_43EFFFFFFFFFFFFF_01 +000FFFFBFFFC0000_432FFFF7FFF80000_00 +0000000000CD5A23_4169AB4460000000_00 +FFFFFFFFFFFFFFDF_43EFFFFFFFFFFFFF_01 +FFBFDFFFBFFFFFFF_43EFF7FBFFF7FFFF_01 +00000000000000FF_406FE00000000000_00 +FFFFFFFFFFFFFFBF_43EFFFFFFFFFFFFF_01 +00000007FF800003_421FFE00000C0000_00 +00000000000ABB02_4125760400000000_00 +FFFFFFFFFFFFFF7F_43EFFFFFFFFFFFFF_01 +FFFFFFFFFFFEE7FF_43EFFFFFFFFFFFDC_01 +00664B2B9BAD0DA2_435992CAE6EB4368_01 +FFFFFFFFFFFFFEFF_43EFFFFFFFFFFFFF_01 +0000000000100803_4130080300000000_00 +009B1DCB9F857D5E_436363B973F0AFAB_01 +FFFFFFFFFFFFFDFF_43EFFFFFFFFFFFFF_01 +FFFFFFBFFFFFEFEE_43EFFFFFF7FFFFFD_01 +36FD7542899C1C6F_43CB7EBAA144CE0E_01 +FFFFFFFFFFFFFBFF_43EFFFFFFFFFFFFF_01 +FF800000004001FF_43EFF00000000800_01 +0000000006BE4932_419AF924C8000000_00 +FFFFFFFFFFFFF7FF_43EFFFFFFFFFFFFE_01 +00001004000FFFFE_42B004000FFFFE00_00 +0000001DAA0123E0_423DAA0123E00000_00 +FFFFFFFFFFFFEFFF_43EFFFFFFFFFFFFD_01 +00000001FDFFFDFE_41FFDFFFDFE00000_00 +00001C8703B1DCB0_42BC8703B1DCB000_00 +FFFFFFFFFFFFDFFF_43EFFFFFFFFFFFFB_01 +FE0FE00000000000_43EFC1FC00000000_00 +0F79ED944A4E2779_43AEF3DB28949C4E_01 +FFFFFFFFFFFFBFFF_43EFFFFFFFFFFFF7_01 +FBFFFE0400000000_43EF7FFFC0800000_00 +0000030127E03666_4288093F01B33000_00 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFEF_01 +FFFFF0200000FFFE_43EFFFFE0400001F_01 +000000000000017F_4077F00000000000_00 +FFFFFFFFFFFEFFFF_43EFFFFFFFFFFFDF_01 +FFEFFE0000080000_43EFFDFFC0000100_00 +00000000013354EA_4173354EA0000000_00 +FFFFFFFFFFFDFFFF_43EFFFFFFFFFFFBF_01 +003FF0000003FFFE_434FF8000001FFFF_00 +0000016375B23F7B_4276375B23F7B000_00 +FFFFFFFFFFFBFFFF_43EFFFFFFFFFFF7F_01 +000407FFFFFFFFF6_43101FFFFFFFFFD8_00 +0000000192117F38_41F92117F3800000_00 +FFFFFFFFFFF7FFFF_43EFFFFFFFFFFEFF_01 +FFFFFFFFFFFF7FFF_43EFFFFFFFFFFFEF_01 +00000000000018BE_40B8BE0000000000_00 +FFFFFFFFFFEFFFFF_43EFFFFFFFFFFDFF_01 +004000020FFFFFFF_4350000083FFFFFF_01 +0000B84C2D8BC9CB_42E70985B1793960_00 +FFFFFFFFFFDFFFFF_43EFFFFFFFFFFBFF_01 +00FFFFFFFFFFFFFD_436FFFFFFFFFFFFF_01 +00000223C2C6F284_42811E1637942000_00 +FFFFFFFFFFBFFFFF_43EFFFFFFFFFF7FF_01 +FFFDDFFFFFFFFFFD_43EFFFBBFFFFFFFF_01 +00000000F46356C4_41EE8C6AD8800000_00 +FFFFFFFFFF7FFFFF_43EFFFFFFFFFEFFF_01 +010000000000BFFF_4370000000000BFF_01 +0000000000000005_4014000000000000_00 +FFFFFFFFFEFFFFFF_43EFFFFFFFFFDFFF_01 +FFFFBF7FFBFFFFFE_43EFFFF7EFFF7FFF_01 +00000026386CE889_42431C3674448000_00 +FFFFFFFFFDFFFFFF_43EFFFFFFFFFBFFF_01 +F00000F7FFFFFFFF_43EE00001EFFFFFF_01 +0001FC53090C46A4_42FFC53090C46A40_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF7FFF_01 +0000000000800047_41600008E0000000_00 +000000001693872E_41B693872E000000_00 +FFFFFFFFF7FFFFFF_43EFFFFFFFFEFFFF_01 +000000007FBFFBFF_41DFEFFEFFC00000_00 +00000226A7845E35_4281353C22F1A800_00 +FFFFFFFFEFFFFFFF_43EFFFFFFFFDFFFF_01 +FFFFFFDFFFFFFBFD_43EFFFFFFBFFFFFF_01 +000000005433D14C_41D50CF453000000_00 +FFFFFFFFDFFFFFFF_43EFFFFFFFFBFFFF_01 +0001FFFFFFE0000E_42FFFFFFFE0000E0_00 +00F23E8068D3D84A_436E47D00D1A7B09_01 +FFFFFFFFBFFFFFFF_43EFFFFFFFF7FFFF_01 +F7FFBFFFFFFFBFFF_43EEFFF7FFFFFFF7_01 +0000BD29B7459087_42E7A536E8B210E0_00 +FFFFFFFF7FFFFFFF_43EFFFFFFFEFFFFF_01 +FFFFFFF8FFFFBFFF_43EFFFFFFF1FFFF7_01 +00000000002DDC06_4146EE0300000000_00 +FFFFFFFEFFFFFFFF_43EFFFFFFFDFFFFF_01 +FFFFFFF80001FFFF_43EFFFFFFF00003F_01 +0000000000012FF9_40F2FF9000000000_00 +FFFFFFFDFFFFFFFF_43EFFFFFFFBFFFFF_01 +004000040000FFFF_4350000100003FFF_01 +0000000000000001_3FF0000000000000_00 +FFFFFFFBFFFFFFFF_43EFFFFFFF7FFFFF_01 +C0000000007FFFFA_43E8000000000FFF_01 +0000000006053E2B_419814F8AC000000_00 +FFFFFFF7FFFFFFFF_43EFFFFFFEFFFFFF_01 +7FFE000007FFFFFF_43DFFF800001FFFF_01 +000000000000002D_4046800000000000_00 +FFFFFFEFFFFFFFFF_43EFFFFFFDFFFFFF_01 +F80000000001007E_43EF000000000020_01 +00000D48424AD9D6_42AA908495B3AC00_00 +FFFFFFDFFFFFFFFF_43EFFFFFFBFFFFFF_01 +FFFFFE0001FEFFFF_43EFFFFFC0003FDF_01 +000000000000033B_4089D80000000000_00 +FFFFFFBFFFFFFFFF_43EFFFFFF7FFFFFF_01 +0007FBFFFFFDFFFE_431FEFFFFFF7FFF8_00 +4A16BD4128090C83_43D285AF504A0243_01 +FFFFFF7FFFFFFFFF_43EFFFFFEFFFFFFF_01 +00FFF7FFFF7FFFFE_436FFEFFFFEFFFFF_01 +0000000000000086_4060C00000000000_00 +FFFFFEFFFFFFFFFF_43EFFFFFDFFFFFFF_01 +FBFFFFBFFFBFFFFF_43EF7FFFF7FFF7FF_01 +00000000000021BA_40C0DD0000000000_00 +FFFFFDFFFFFFFFFF_43EFFFFFBFFFFFFF_01 +0000000040000082_41D0000020800000_00 +0007A2BF5B689F89_431E8AFD6DA27E24_00 +FFFFFBFFFFFFFFFF_43EFFFFF7FFFFFFF_01 +0000001FF8000008_423FF80000080000_00 +387CAA7DE672DE8B_43CC3E553EF3396F_01 +FFFFF7FFFFFFFFFF_43EFFFFEFFFFFFFF_01 +07FFF80000000002_439FFFE000000000_01 +0000000030A1E5B8_41C850F2DC000000_00 +FFFFEFFFFFFFFFFF_43EFFFFDFFFFFFFF_01 +F7FFFFE00007FFFF_43EEFFFFFC0000FF_01 +000000000006ADFC_411AB7F000000000_00 +FFFFDFFFFFFFFFFF_43EFFFFBFFFFFFFF_01 +FFFFFF03FFFFFFC0_43EFFFFFE07FFFFF_01 +0A579475948F0032_43A4AF28EB291E00_01 +FFFFBFFFFFFFFFFF_43EFFFF7FFFFFFFF_01 +FC00000000003FF6_43EF800000000007_01 +00AE677AC313BF60_4365CCEF586277EC_00 +FFFF7FFFFFFFFFFF_43EFFFEFFFFFFFFF_01 +02000007FF7FFFFF_438000003FFBFFFF_01 +0000002E999639F1_42474CCB1CF88000_00 +FFFEFFFFFFFFFFFF_43EFFFDFFFFFFFFF_01 +FFFF83FFFFFFFFBE_43EFFFF07FFFFFFF_01 +000000000003537D_410A9BE800000000_00 +FFFDFFFFFFFFFFFF_43EFFFBFFFFFFFFF_01 +EFFFFFC00000003D_43EDFFFFF8000000_01 +000000121FEDFD35_42321FEDFD350000_00 +FFFBFFFFFFFFFFFF_43EFFF7FFFFFFFFF_01 +FFFFFFF0000007FE_43EFFFFFFE000000_01 +00000000001E0839_413E083900000000_00 +FFF7FFFFFFFFFFFF_43EFFEFFFFFFFFFF_01 +0000007FFFE000FF_425FFFF8003FC000_00 +0000000079F30F48_41DE7CC3D2000000_00 +FFEFFFFFFFFFFFFF_43EFFDFFFFFFFFFF_01 +FFFFFC13FFFFFFFD_43EFFFFF827FFFFF_01 +0000000000003B85_40CDC28000000000_00 +FFDFFFFFFFFFFFFF_43EFFBFFFFFFFFFF_01 +000008000007FFFE_42A000000FFFFC00_00 +32DB4409E5AE87E6_43C96DA204F2D743_01 +FFBFFFFFFFFFFFFF_43EFF7FFFFFFFFFF_01 +FFFFFFFFFFF7BFEE_43EFFFFFFFFFFEF7_01 +000000000000003D_404E800000000000_00 +FF7FFFFFFFFFFFFF_43EFEFFFFFFFFFFF_01 +000000001040FFFE_41B040FFFE000000_00 +00004909A09C13D3_42D242682704F4C0_00 +FEFFFFFFFFFFFFFF_43EFDFFFFFFFFFFF_01 +FFFFFF01FFFFFF7F_43EFFFFFE03FFFFF_01 +00000072E7D2575D_425CB9F495D74000_00 +FDFFFFFFFFFFFFFF_43EFBFFFFFFFFFFF_01 +FFFFFFFFFFFEFFDB_43EFFFFFFFFFFFDF_01 +0000000000000057_4055C00000000000_00 +FBFFFFFFFFFFFFFF_43EF7FFFFFFFFFFF_01 +100000001FFFFFF6_43B00000001FFFFF_01 +000000914B12EF51_426229625DEA2000_00 +F7FFFFFFFFFFFFFF_43EEFFFFFFFFFFFF_01 +0407FFFFFFFFFEFF_43901FFFFFFFFFFB_01 +000000769F3A5C2C_425DA7CE970B0000_00 +EFFFFFFFFFFFFFFF_43EDFFFFFFFFFFFF_01 +FFFFFFFDF7FFFFFD_43EFFFFFFFBEFFFF_01 +0000000000000002_4000000000000000_00 +DFFFFFFFFFFFFFFF_43EBFFFFFFFFFFFF_01 +FFFFFFFFFE0007FF_43EFFFFFFFFFC000_01 +000000000000009E_4063C00000000000_00 +BFFFFFFFFFFFFFFF_43E7FFFFFFFFFFFF_01 +FFF800000009FFFF_43EFFF000000013F_01 +0000000000087AA4_4120F54800000000_00 +7FFFFFFFFFFFFFFF_43DFFFFFFFFFFFFF_01 +4080000000FFFFFF_43D0200000003FFF_01 +000000001DE7601D_41BDE7601D000000_00 +3FFFFFFFFFFFFFFF_43CFFFFFFFFFFFFF_01 +FFCFFFFFFFBFFFFE_43EFF9FFFFFFF7FF_01 +000000000000004A_4052800000000000_00 +1FFFFFFFFFFFFFFF_43BFFFFFFFFFFFFF_01 +000080400000003F_42E00800000007E0_00 +00000000003F75A5_414FBAD280000000_00 +0FFFFFFFFFFFFFFF_43AFFFFFFFFFFFFF_01 +FFFFFFEFFFFFCFFE_43EFFFFFFDFFFFF9_01 +000000E775887420_426CEEB10E840000_00 +07FFFFFFFFFFFFFF_439FFFFFFFFFFFFF_01 +00000000000801FE_412003FC00000000_00 +0000000000A13FF1_416427FE20000000_00 +03FFFFFFFFFFFFFF_438FFFFFFFFFFFFF_01 +07FEFFFFFFFFFFEE_439FFBFFFFFFFFFF_01 +000000000000000C_4028000000000000_00 +01FFFFFFFFFFFFFF_437FFFFFFFFFFFFF_01 +0000000820000003_4220400000060000_00 +00000001AD105214_41FAD10521400000_00 +00FFFFFFFFFFFFFF_436FFFFFFFFFFFFF_01 +FFFFF00FFFFFFFBE_43EFFFFE01FFFFFF_01 +0000000000CC48E7_4169891CE0000000_00 +007FFFFFFFFFFFFF_435FFFFFFFFFFFFF_01 +00000FFFEF7FFFFF_42AFFFDEFFFFFE00_00 +00000000000BA6CB_41274D9600000000_00 +003FFFFFFFFFFFFF_434FFFFFFFFFFFFF_01 +FFFFFF7FBFFFFFBF_43EFFFFFEFF7FFFF_01 +0000000000024425_4102212800000000_00 +001FFFFFFFFFFFFF_433FFFFFFFFFFFFF_00 +200000001FFBFFFF_43C00000000FFDFF_01 +0000004E7115EC53_42539C457B14C000_00 +000FFFFFFFFFFFFF_432FFFFFFFFFFFFE_00 +FFFFF803FFFFFFBF_43EFFFFF007FFFFF_01 +0000002E539ADCFE_424729CD6E7F0000_00 +0007FFFFFFFFFFFF_431FFFFFFFFFFFFC_00 +FFFFFFFFFBFFFFFF_43EFFFFFFFFF7FFF_01 +000000D5084732F3_426AA108E65E6000_00 +0003FFFFFFFFFFFF_430FFFFFFFFFFFF8_00 +BFFF7FFFFFFFFE00_43E7FFEFFFFFFFFF_01 +0000000000000543_40950C0000000000_00 +0001FFFFFFFFFFFF_42FFFFFFFFFFFFF0_00 +0000001FFBFFE000_423FFBFFE0000000_00 +000000000000491B_40D246C000000000_00 +0000FFFFFFFFFFFF_42EFFFFFFFFFFFE0_00 +FC00200000001FFE_43EF800400000003_01 +0000016898822A24_4276898822A24000_00 +00007FFFFFFFFFFF_42DFFFFFFFFFFFC0_00 +3FFF03FFFFFFFFFE_43CFFF81FFFFFFFF_01 +0000000FFE18C7BF_422FFC318F7E0000_00 +00003FFFFFFFFFFF_42CFFFFFFFFFFF80_00 +FFFFFEFFFEFFFFFD_43EFFFFFDFFFDFFF_01 +02F03620C1266ED9_438781B106093376_01 +00001FFFFFFFFFFF_42BFFFFFFFFFFF00_00 +BF7EFFFFFFFFFFFF_43E7EFDFFFFFFFFF_01 +0000000000000055_4055400000000000_00 +00000FFFFFFFFFFF_42AFFFFFFFFFFE00_00 +FFFBFFFFF803FFFE_43EFFF7FFFFF007F_01 +0000000000168684_4136868400000000_00 +000007FFFFFFFFFF_429FFFFFFFFFFC00_00 +DFFFFFE00000001E_43EBFFFFFC000000_01 +0000000000000CF5_40A9EA0000000000_00 +000003FFFFFFFFFF_428FFFFFFFFFF800_00 +FFFF00400000FFFF_43EFFFE00800001F_01 +0000000000000022_4041000000000000_00 +000001FFFFFFFFFF_427FFFFFFFFFF000_00 +FBFFFFFFFFFFBDFE_43EF7FFFFFFFFFF7_01 +0000000000001BC9_40BBC90000000000_00 +000000FFFFFFFFFF_426FFFFFFFFFE000_00 +807FFFFFFFFFDFFE_43E00FFFFFFFFFFB_01 +000274E35A70CD76_4303A71AD3866BB0_00 +0000007FFFFFFFFF_425FFFFFFFFFC000_00 +0FFFFFFFFEFFFFFD_43AFFFFFFFFDFFFF_01 +0000000300E73AFC_42080739D7E00000_00 +0000003FFFFFFFFF_424FFFFFFFFF8000_00 +FFC000000001000E_43EFF80000000020_01 +00000000000615E9_411857A400000000_00 +0000001FFFFFFFFF_423FFFFFFFFF0000_00 +0001FFFFFFFFF3FD_42FFFFFFFFFF3FD0_00 +00000000000000B3_4066600000000000_00 +0000000FFFFFFFFF_422FFFFFFFFE0000_00 +000000001FFFBFFF_41BFFFBFFF000000_00 +0000006E6B141E1B_425B9AC50786C000_00 +00000007FFFFFFFF_421FFFFFFFFC0000_00 +FFFFFFFFF60007FF_43EFFFFFFFFEC000_01 +00000003AB310BA6_420D59885D300000_00 +00000003FFFFFFFF_420FFFFFFFF80000_00 +0003FFFFB7FFFFFF_430FFFFDBFFFFFF8_00 +0000000000000195_4079500000000000_00 +00000001FFFFFFFF_41FFFFFFFFF00000_00 +FFFFFFFF8000000B_43EFFFFFFFF00000_01 +00000059BA8D5559_42566EA355564000_00 +00000000FFFFFFFF_41EFFFFFFFE00000_00 +FBFEFFFFFFFFFFF9_43EF7FDFFFFFFFFF_01 +000001B6F062822D_427B6F062822D000_00 +000000007FFFFFFF_41DFFFFFFFC00000_00 +0001000000000082_42F0000000000820_00 +03CEAD9E2FB104A4_438E756CF17D8825_01 +000000003FFFFFFF_41CFFFFFFF800000_00 +000003FFFFFFFF7C_428FFFFFFFFBE000_00 +000000000D681E78_41AAD03CF0000000_00 +000000001FFFFFFF_41BFFFFFFF000000_00 +00002000400001FF_42C000200000FF80_00 +0000000000000058_4056000000000000_00 +000000000FFFFFFF_41AFFFFFFE000000_00 +3FFF80000000003E_43CFFFC000000000_01 +0000000000000095_4062A00000000000_00 +0000000007FFFFFF_419FFFFFFC000000_00 +010000BFFFFFFFFF_4370000BFFFFFFFF_01 +0000009697087B19_4262D2E10F632000_00 +0000000003FFFFFF_418FFFFFF8000000_00 +FBFFFFFFFFEEFFFD_43EF7FFFFFFFFDDF_01 +0000001E64BDFC55_423E64BDFC550000_00 +0000000001FFFFFF_417FFFFFF0000000_00 +FC00000001FFFFFE_43EF800000003FFF_01 +0000D156A62AB849_42EA2AD4C5570920_00 +0000000000FFFFFF_416FFFFFE0000000_00 +FFFFFFF83FEFFFFD_43EFFFFFFF07FDFF_01 +00035354EAE7C259_430A9AA7573E12C8_00 +00000000007FFFFF_415FFFFFC0000000_00 +FFFFFFFFFFFFFF7F_43EFFFFFFFFFFFFF_01 +00000000F4DF3C75_41EE9BE78EA00000_00 +00000000003FFFFF_414FFFFF80000000_00 +FFFA000000001FFF_43EFFF4000000003_01 +0000000000000003_4008000000000000_00 +00000000001FFFFF_413FFFFF00000000_00 +FFFFFFFFFF7FFE40_43EFFFFFFFFFEFFF_01 +0000005B5433CB9B_4256D50CF2E6C000_00 +00000000000FFFFF_412FFFFE00000000_00 +FFFFFDFFDFFDFFFD_43EFFFFFBFFBFFBF_01 +0000000000DEAE1F_416BD5C3E0000000_00 +000000000007FFFF_411FFFFC00000000_00 +FFFFFFFFF0080006_43EFFFFFFFFE0100_01 +000000007735DEC7_41DDCD77B1C00000_00 +000000000003FFFF_410FFFF800000000_00 +00000001FBFFFFFF_41FFBFFFFFF00000_00 +000007757D8B12ED_429DD5F62C4BB400_00 +000000000001FFFF_40FFFFF000000000_00 +FFFFFE07F7FFFFFF_43EFFFFFC0FEFFFF_01 +00002A654064E046_42C532A032702300_00 +000000000000FFFF_40EFFFE000000000_00 +08000000000017FF_43A000000000002F_01 +0000000000000007_401C000000000000_00 +0000000000007FFF_40DFFFC000000000_00 +07FFFFFFFFFFFDF6_439FFFFFFFFFFFF7_01 +00002D78B3D6C3B6_42C6BC59EB61DB00_00 +0000000000003FFF_40CFFF8000000000_00 +0000300004000000_42C8000200000000_00 +000000070B77F34F_421C2DDFCD3C0000_00 +0000000000001FFF_40BFFF0000000000_00 +FFFFFF80006FFFFE_43EFFFFFF0000DFF_01 +0000093EB4D67EC8_42A27D69ACFD9000_00 +0000000000000FFF_40AFFE0000000000_00 +BFFFDFFFFBFFFFFF_43E7FFFBFFFF7FFF_01 +0205CEAF34EA1DC7_43802E7579A750EE_01 +00000000000007FF_409FFC0000000000_00 +00004800007FFFFD_42D200001FFFFF40_00 +0000000000000003_4008000000000000_00 +00000000000003FF_408FF80000000000_00 +0000000200001000_4200000080000000_00 +00000000000760D0_411D834000000000_00 +00000000000001FF_407FF00000000000_00 +01003FFFFFFFFFFC_437003FFFFFFFFFF_01 +02C000708FF1BA51_43860003847F8DD2_01 +00000000000000FF_406FE00000000000_00 +F802000003FFFFFF_43EF004000007FFF_01 +4F9E07DCC0BDC061_43D3E781F7302F70_01 +000000000000007F_405FC00000000000_00 +03FF0000000000FF_438FF80000000007_01 +00000001B9B2A079_41FB9B2A07900000_00 +000000000000003F_404F800000000000_00 +FFF80000000080FF_43EFFF0000000010_01 +00000000005EB5B4_4157AD6D00000000_00 +000000000000001F_403F000000000000_00 +000000000077FBFE_415DFEFF80000000_00 +0000000000DAC607_416B58C0E0000000_00 +000000000000000F_402E000000000000_00 +FFFFFFFEF80000FF_43EFFFFFFFDF0000_01 +00000DC5B9D66984_42AB8B73ACD30800_00 +0000000000000007_401C000000000000_00 +C001FFFFFFF00000_43E8003FFFFFFE00_00 +00003D06B372AA06_42CE8359B9550300_00 +0000000000000003_4008000000000000_00 diff --git a/wally-pipelined/testbench/fp/undy.sh b/wally-pipelined/testbench/fp/undy.sh new file mode 100755 index 000000000..887dbeaf1 --- /dev/null +++ b/wally-pipelined/testbench/fp/undy.sh @@ -0,0 +1,2 @@ +#!/bin/sh +sed -i 's/ /_/g' $1 From 1824b2af1392421f0f86b16d30021299199cbc1a Mon Sep 17 00:00:00 2001 From: bbracker Date: Thu, 7 Oct 2021 18:55:00 -0400 Subject: [PATCH 014/118] fix div restarting bug --- wally-pipelined/src/muldiv/intdivrestoring.sv | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wally-pipelined/src/muldiv/intdivrestoring.sv b/wally-pipelined/src/muldiv/intdivrestoring.sv index 5ab9b2b8c..12ce38759 100644 --- a/wally-pipelined/src/muldiv/intdivrestoring.sv +++ b/wally-pipelined/src/muldiv/intdivrestoring.sv @@ -125,7 +125,7 @@ module intdivrestoring ( DivDoneM = 1; end end else if (DivDoneM) begin - DivDoneM = 0; + DivDoneM = StallM; BusyE = 0; end From 55f6584e628f3bbda7f864f2648758ea4c16d0ba Mon Sep 17 00:00:00 2001 From: bbracker Date: Thu, 7 Oct 2021 19:16:52 -0400 Subject: [PATCH 015/118] update wave-do --- wally-pipelined/regression/linux-wave.do | 393 +++++++++++------------ 1 file changed, 196 insertions(+), 197 deletions(-) diff --git a/wally-pipelined/regression/linux-wave.do b/wally-pipelined/regression/linux-wave.do index 7a0ee7bd9..7c7a300bd 100644 --- a/wally-pipelined/regression/linux-wave.do +++ b/wally-pipelined/regression/linux-wave.do @@ -2,6 +2,7 @@ onerror {resume} quietly WaveActivateNextPane {} 0 add wave -noupdate /testbench/clk add wave -noupdate /testbench/reset +add wave -noupdate -radix unsigned /testbench/InstrCountW add wave -noupdate /testbench/dut/hart/SATP_REGW add wave -noupdate -expand -group {Execution Stage} /testbench/dut/hart/ifu/PCE add wave -noupdate -expand -group {Execution Stage} /testbench/InstrEName @@ -30,25 +31,26 @@ add wave -noupdate -expand -group HDU -group traps /testbench/dut/hart/priv/trap add wave -noupdate -expand -group HDU -group interrupts /testbench/dut/hart/priv/trap/PendingIntsM add wave -noupdate -expand -group HDU -group interrupts /testbench/dut/hart/priv/trap/CommittedM add wave -noupdate -expand -group HDU -group interrupts /testbench/dut/hart/priv/trap/InstrValidM -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/hzu/BPPredWrongE -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/hzu/CSRWritePendingDEM -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/hzu/RetM -add wave -noupdate -expand -group HDU -group hazards -color Pink /testbench/dut/hart/hzu/TrapM -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/hzu/LoadStallD -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/hzu/StoreStallD -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/hzu/ICacheStallF -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/hzu/LSUStall -add wave -noupdate -expand -group HDU -group hazards /testbench/dut/hart/MulDivStallD +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/BPPredWrongE +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/CSRWritePendingDEM +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/RetM +add wave -noupdate -expand -group HDU -expand -group hazards -color Pink /testbench/dut/hart/hzu/TrapM +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/LoadStallD +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/StoreStallD +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/ICacheStallF +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/LSUStall +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/MulDivStallD +add wave -noupdate -expand -group HDU -expand -group hazards /testbench/dut/hart/hzu/DivBusyE add wave -noupdate -expand -group HDU -group Flush -color Yellow /testbench/dut/hart/hzu/FlushF add wave -noupdate -expand -group HDU -group Flush -color Yellow /testbench/dut/hart/FlushD add wave -noupdate -expand -group HDU -group Flush -color Yellow /testbench/dut/hart/FlushE add wave -noupdate -expand -group HDU -group Flush -color Yellow /testbench/dut/hart/FlushM add wave -noupdate -expand -group HDU -group Flush -color Yellow /testbench/dut/hart/FlushW -add wave -noupdate -expand -group HDU -group Stall -color Orange /testbench/dut/hart/StallF -add wave -noupdate -expand -group HDU -group Stall -color Orange /testbench/dut/hart/StallD -add wave -noupdate -expand -group HDU -group Stall -color Orange /testbench/dut/hart/StallE -add wave -noupdate -expand -group HDU -group Stall -color Orange /testbench/dut/hart/StallM -add wave -noupdate -expand -group HDU -group Stall -color Orange /testbench/dut/hart/StallW +add wave -noupdate -expand -group HDU -expand -group Stall -color Orange /testbench/dut/hart/StallF +add wave -noupdate -expand -group HDU -expand -group Stall -color Orange /testbench/dut/hart/StallD +add wave -noupdate -expand -group HDU -expand -group Stall -color Orange /testbench/dut/hart/StallE +add wave -noupdate -expand -group HDU -expand -group Stall -color Orange /testbench/dut/hart/StallM +add wave -noupdate -expand -group HDU -expand -group Stall -color Orange /testbench/dut/hart/StallW add wave -noupdate -group Bpred -color Orange /testbench/dut/hart/ifu/bpred/bpred/Predictor/DirPredictor/GHR add wave -noupdate -group Bpred -expand -group {branch update selection inputs} /testbench/dut/hart/ifu/bpred/bpred/Predictor/DirPredictor/BPPredF add wave -noupdate -group Bpred -expand -group {branch update selection inputs} {/testbench/dut/hart/ifu/bpred/bpred/Predictor/DirPredictor/InstrClassE[0]} @@ -158,12 +160,12 @@ add wave -noupdate -group {alu execution stage} /testbench/dut/hart/ieu/dp/Write add wave -noupdate -group {alu execution stage} /testbench/dut/hart/ieu/dp/ALUResultE add wave -noupdate -group {alu execution stage} /testbench/dut/hart/ieu/dp/SrcAE add wave -noupdate -group {alu execution stage} /testbench/dut/hart/ieu/dp/SrcBE -add wave -noupdate -group PCS /testbench/dut/hart/ifu/PCNextF -add wave -noupdate -group PCS /testbench/dut/hart/PCF -add wave -noupdate -group PCS /testbench/dut/hart/ifu/PCD -add wave -noupdate -group PCS /testbench/dut/hart/PCE -add wave -noupdate -group PCS /testbench/dut/hart/PCM -add wave -noupdate -group PCS /testbench/PCW +add wave -noupdate -expand -group PCS /testbench/dut/hart/ifu/PCNextF +add wave -noupdate -expand -group PCS /testbench/dut/hart/PCF +add wave -noupdate -expand -group PCS /testbench/dut/hart/ifu/PCD +add wave -noupdate -expand -group PCS /testbench/dut/hart/PCE +add wave -noupdate -expand -group PCS /testbench/dut/hart/PCM +add wave -noupdate -expand -group PCS /testbench/PCW add wave -noupdate -group muldiv /testbench/dut/hart/mdu/InstrD add wave -noupdate -group muldiv /testbench/dut/hart/mdu/SrcAE add wave -noupdate -group muldiv /testbench/dut/hart/mdu/SrcBE @@ -175,41 +177,38 @@ add wave -noupdate -group muldiv /testbench/dut/hart/mdu/StallW add wave -noupdate -group muldiv /testbench/dut/hart/mdu/FlushM add wave -noupdate -group muldiv /testbench/dut/hart/mdu/FlushW add wave -noupdate -group muldiv /testbench/dut/hart/mdu/MulDivResultW -add wave -noupdate -group muldiv /testbench/dut/hart/mdu/genblk1/div/start -add wave -noupdate -group muldiv /testbench/dut/hart/mdu/DivDoneM add wave -noupdate -group muldiv /testbench/dut/hart/mdu/DivBusyE -add wave -noupdate -group divider /testbench/dut/hart/mdu/genblk1/div/fsm1/CURRENT_STATE -add wave -noupdate -group divider /testbench/dut/hart/mdu/genblk1/div/N -add wave -noupdate -group divider /testbench/dut/hart/mdu/genblk1/div/D -add wave -noupdate -group divider /testbench/dut/hart/mdu/genblk1/div/Q -add wave -noupdate -group divider /testbench/dut/hart/mdu/genblk1/div/rem0 -add wave -noupdate -group icache -color Gold /testbench/dut/hart/ifu/icache/controller/CurrState -add wave -noupdate -group icache /testbench/dut/hart/ifu/icache/controller/NextState -add wave -noupdate -group icache /testbench/dut/hart/ifu/ITLBMissF -add wave -noupdate -group icache /testbench/dut/hart/ifu/icache/ITLBWriteF -add wave -noupdate -group icache /testbench/dut/hart/ifu/icache/ReadLineF -add wave -noupdate -group icache /testbench/dut/hart/ifu/icache/PCNextIndexF -add wave -noupdate -group icache /testbench/dut/hart/ifu/icache/ReadLineF -add wave -noupdate -group icache {/testbench/dut/hart/ifu/icache/MemWay[0]/ValidBits} -add wave -noupdate -group icache {/testbench/dut/hart/ifu/icache/MemWay[1]/ValidBits} -add wave -noupdate -group icache {/testbench/dut/hart/ifu/icache/MemWay[2]/ValidBits} -add wave -noupdate -group icache {/testbench/dut/hart/ifu/icache/MemWay[3]/ValidBits} -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/hit -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/spill -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/ICacheStallF -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/SavePC -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/spillSave -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/UnalignedSelect -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/spillSave -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/CntReset -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/PreCntEn -add wave -noupdate -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/CntEn -add wave -noupdate -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/FetchCountFlag -add wave -noupdate -group icache -expand -group memory /testbench/dut/hart/ifu/icache/FetchCount -add wave -noupdate -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/InstrReadF -add wave -noupdate -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/InstrAckF -add wave -noupdate -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/ICacheMemWriteEnable -add wave -noupdate -group icache -expand -group memory /testbench/dut/hart/ifu/icache/ICacheMemWriteData +add wave -noupdate /testbench/dut/hart/mdu/genblk1/div/StartDivideE +add wave -noupdate /testbench/dut/hart/mdu/genblk1/div/BusyE +add wave -noupdate /testbench/dut/hart/mdu/genblk1/div/DivDoneM +add wave -noupdate /testbench/dut/hart/mdu/genblk1/div/DivInitE +add wave -noupdate -expand -group icache -color Gold /testbench/dut/hart/ifu/icache/controller/CurrState +add wave -noupdate -expand -group icache /testbench/dut/hart/ifu/icache/controller/NextState +add wave -noupdate -expand -group icache /testbench/dut/hart/ifu/ITLBMissF +add wave -noupdate -expand -group icache /testbench/dut/hart/ifu/icache/ITLBWriteF +add wave -noupdate -expand -group icache /testbench/dut/hart/ifu/icache/ReadLineF +add wave -noupdate -expand -group icache /testbench/dut/hart/ifu/icache/PCNextIndexF +add wave -noupdate -expand -group icache /testbench/dut/hart/ifu/icache/ReadLineF +add wave -noupdate -expand -group icache {/testbench/dut/hart/ifu/icache/MemWay[0]/ValidBits} +add wave -noupdate -expand -group icache {/testbench/dut/hart/ifu/icache/MemWay[1]/ValidBits} +add wave -noupdate -expand -group icache {/testbench/dut/hart/ifu/icache/MemWay[2]/ValidBits} +add wave -noupdate -expand -group icache {/testbench/dut/hart/ifu/icache/MemWay[3]/ValidBits} +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/hit +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/spill +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/ICacheStallF +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/SavePC +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/spillSave +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/UnalignedSelect +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/spillSave +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/CntReset +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/PreCntEn +add wave -noupdate -expand -group icache -expand -group {fsm out and control} /testbench/dut/hart/ifu/icache/controller/CntEn +add wave -noupdate -expand -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/FetchCountFlag +add wave -noupdate -expand -group icache -expand -group memory /testbench/dut/hart/ifu/icache/FetchCount +add wave -noupdate -expand -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/InstrReadF +add wave -noupdate -expand -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/InstrAckF +add wave -noupdate -expand -group icache -expand -group memory /testbench/dut/hart/ifu/icache/controller/ICacheMemWriteEnable +add wave -noupdate -expand -group icache -expand -group memory /testbench/dut/hart/ifu/icache/ICacheMemWriteData add wave -noupdate -group AHB -color Gold /testbench/dut/hart/ebu/BusState add wave -noupdate -group AHB /testbench/dut/hart/ebu/NextBusState add wave -noupdate -group AHB -expand -group {input requests} /testbench/dut/hart/ebu/AtomicMaskedM @@ -232,133 +231,133 @@ add wave -noupdate -group AHB /testbench/dut/hart/ebu/HADDRD add wave -noupdate -group AHB /testbench/dut/hart/ebu/HSIZED add wave -noupdate -group AHB /testbench/dut/hart/ebu/HWRITED add wave -noupdate -group AHB /testbench/dut/hart/ebu/StallW -add wave -noupdate -expand -group lsu -expand -group {LSU ARB} /testbench/dut/hart/lsu/arbiter/SelPTW -add wave -noupdate -expand -group lsu -expand -group dcache -color Gold /testbench/dut/hart/lsu/dcache/dcachefsm/CurrState -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/WalkerPageFaultM -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/WriteDataM -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/SRAMBlockWriteEnableM -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/SRAMWordWriteEnableM -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/SRAMWayWriteEnable -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/SRAMWordEnable -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/SRAMBlockWayWriteEnableM -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/SelAdrM -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/ReadDataBlockM -add wave -noupdate -expand -group lsu -expand -group dcache -group flush -radix unsigned /testbench/dut/hart/lsu/dcache/FlushAdr -add wave -noupdate -expand -group lsu -expand -group dcache -group flush /testbench/dut/hart/lsu/dcache/FlushWay -add wave -noupdate -expand -group lsu -expand -group dcache -group flush /testbench/dut/hart/lsu/dcache/VictimDirtyWay -add wave -noupdate -expand -group lsu -expand -group dcache -group flush /testbench/dut/hart/lsu/dcache/VictimTag -add wave -noupdate -expand -group lsu -expand -group dcache -group flush /testbench/dut/hart/lsu/dcache/BasePAdrM -add wave -noupdate -expand -group lsu -expand -group dcache -group flush /testbench/dut/hart/lsu/dcache/FetchCount -add wave -noupdate -expand -group lsu -expand -group dcache -group flush /testbench/dut/hart/lsu/dcache/CacheableM -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/DCacheMemWriteData -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/SetValid} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/SetDirty} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[0]/CacheTagMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/DirtyBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/ValidBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[0]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[0]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word1 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[1]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word1 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[1]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word2 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[2]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word2 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[2]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word3 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[3]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word3 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[3]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/DirtyBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/ValidBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/SetDirty} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/WriteWordEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[1]/CacheTagMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word0 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[0]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word0 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[0]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[1]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[1]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word2 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[2]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word2 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[2]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word3 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[3]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word3 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[3]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/SetValid} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/SetDirty} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[2]/CacheTagMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/DirtyBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/ValidBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word0 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[0]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word0 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[0]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word1 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[1]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word1 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[1]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[2]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[2]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word3 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[3]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word3 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[3]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/SetValid} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/SetDirty} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/ClearDirty} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/VDWriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[3]/CacheTagMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/DirtyBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/ValidBits} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word0 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[0]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word0 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[0]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word1 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[1]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word1 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[1]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word2 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[2]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word2 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[2]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[3]/CacheDataMem/WriteEnable} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[3]/CacheDataMem/StoredData} -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/SetValid -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/ClearValid -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/SetDirty -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/ClearDirty -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/RAdr -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/WayHit} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/Valid} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/Dirty} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/ReadTag} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/WayHit} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/Valid} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/Dirty} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/ReadTag} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/WayHit} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/Valid} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/Dirty} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/ReadTag} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/WayHit} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/Valid} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/Dirty} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/ReadTag} -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/WayHit -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/ReadDataBlockWayMaskedM -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/ReadDataWordM -add wave -noupdate -expand -group lsu -expand -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/ReadDataWordMuxM -add wave -noupdate -expand -group lsu -expand -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimTag -add wave -noupdate -expand -group lsu -expand -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimWay -add wave -noupdate -expand -group lsu -expand -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimDirtyWay -add wave -noupdate -expand -group lsu -expand -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimDirty -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/MemRWM -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/MemAdrE -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/MemPAdrM -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/Funct3M -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/Funct7M -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/AtomicM -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/CacheableM -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/FlushDCacheM -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/WriteDataM -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/ReadDataM -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {CPU side} /testbench/dut/hart/lsu/dcache/DCacheStall -add wave -noupdate -expand -group lsu -expand -group dcache -group status /testbench/dut/hart/lsu/dcache/WayHit -add wave -noupdate -expand -group lsu -expand -group dcache -group status -color {Medium Orchid} /testbench/dut/hart/lsu/dcache/CacheHit -add wave -noupdate -expand -group lsu -expand -group dcache -group status /testbench/dut/hart/lsu/dcache/FetchCount -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBPAdr -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBRead -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBWrite -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBAck -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Memory Side} /testbench/dut/hart/lsu/dcache/HRDATA -add wave -noupdate -expand -group lsu -expand -group dcache -expand -group {Memory Side} /testbench/dut/hart/lsu/dcache/HWDATA -add wave -noupdate -expand -group lsu -expand -group dcache /testbench/dut/hart/lsu/dcache/FlushWay +add wave -noupdate -expand -group lsu -group {LSU ARB} /testbench/dut/hart/lsu/arbiter/SelPTW +add wave -noupdate -expand -group lsu -group dcache -color Gold /testbench/dut/hart/lsu/dcache/dcachefsm/CurrState +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/WalkerPageFaultM +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/WriteDataM +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/SRAMBlockWriteEnableM +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/SRAMWordWriteEnableM +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/SRAMWayWriteEnable +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/SRAMWordEnable +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/SRAMBlockWayWriteEnableM +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/SelAdrM +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/ReadDataBlockM +add wave -noupdate -expand -group lsu -group dcache -group flush -radix unsigned /testbench/dut/hart/lsu/dcache/FlushAdr +add wave -noupdate -expand -group lsu -group dcache -group flush /testbench/dut/hart/lsu/dcache/FlushWay +add wave -noupdate -expand -group lsu -group dcache -group flush /testbench/dut/hart/lsu/dcache/VictimDirtyWay +add wave -noupdate -expand -group lsu -group dcache -group flush /testbench/dut/hart/lsu/dcache/VictimTag +add wave -noupdate -expand -group lsu -group dcache -group flush /testbench/dut/hart/lsu/dcache/BasePAdrM +add wave -noupdate -expand -group lsu -group dcache -group flush /testbench/dut/hart/lsu/dcache/FetchCount +add wave -noupdate -expand -group lsu -group dcache -group flush /testbench/dut/hart/lsu/dcache/CacheableM +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/DCacheMemWriteData +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/SetValid} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/SetDirty} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[0]/CacheTagMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/DirtyBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/ValidBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[0]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[0]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word1 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[1]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word1 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[1]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word2 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[2]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word2 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[2]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word3 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[3]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way0 -expand -group Way0Word3 {/testbench/dut/hart/lsu/dcache/MemWay[0]/word[3]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/DirtyBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/ValidBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/SetDirty} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/WriteWordEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[1]/CacheTagMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word0 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[0]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word0 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[0]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[1]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[1]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word2 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[2]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word2 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[2]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word3 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[3]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way1 -expand -group Way1Word3 {/testbench/dut/hart/lsu/dcache/MemWay[1]/word[3]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/SetValid} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/SetDirty} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[2]/CacheTagMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/DirtyBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/ValidBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word0 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[0]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word0 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[0]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word1 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[1]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word1 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[1]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[2]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[2]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word3 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[3]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way2 -expand -group Way2Word3 {/testbench/dut/hart/lsu/dcache/MemWay[2]/word[3]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/SetValid} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/SetDirty} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/ClearDirty} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/VDWriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -label TAG {/testbench/dut/hart/lsu/dcache/MemWay[3]/CacheTagMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/DirtyBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/ValidBits} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word0 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[0]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word0 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[0]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word1 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[1]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word1 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[1]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word2 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[2]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word2 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[2]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[3]/CacheDataMem/WriteEnable} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group way3 -expand -group Way3Word3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/word[3]/CacheDataMem/StoredData} +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/SetValid +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/ClearValid +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/SetDirty +add wave -noupdate -expand -group lsu -group dcache -expand -group {Cache SRAM writes} -group valid/dirty /testbench/dut/hart/lsu/dcache/ClearDirty +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/RAdr +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/WayHit} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/Valid} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/Dirty} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way0 {/testbench/dut/hart/lsu/dcache/MemWay[0]/ReadTag} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/WayHit} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/Valid} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/Dirty} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way1 {/testbench/dut/hart/lsu/dcache/MemWay[1]/ReadTag} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/WayHit} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/Valid} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/Dirty} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way2 {/testbench/dut/hart/lsu/dcache/MemWay[2]/ReadTag} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/WayHit} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/Valid} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/Dirty} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} -expand -group way3 {/testbench/dut/hart/lsu/dcache/MemWay[3]/ReadTag} +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/WayHit +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/ReadDataBlockWayMaskedM +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/ReadDataWordM +add wave -noupdate -expand -group lsu -group dcache -group {Cache SRAM read} /testbench/dut/hart/lsu/dcache/ReadDataWordMuxM +add wave -noupdate -expand -group lsu -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimTag +add wave -noupdate -expand -group lsu -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimWay +add wave -noupdate -expand -group lsu -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimDirtyWay +add wave -noupdate -expand -group lsu -group dcache -group Victim /testbench/dut/hart/lsu/dcache/VictimDirty +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/MemRWM +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/MemAdrE +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/MemPAdrM +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/Funct3M +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/Funct7M +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/AtomicM +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/CacheableM +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/FlushDCacheM +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/WriteDataM +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/ReadDataM +add wave -noupdate -expand -group lsu -group dcache -group {CPU side} /testbench/dut/hart/lsu/dcache/DCacheStall +add wave -noupdate -expand -group lsu -group dcache -group status /testbench/dut/hart/lsu/dcache/WayHit +add wave -noupdate -expand -group lsu -group dcache -group status -color {Medium Orchid} /testbench/dut/hart/lsu/dcache/CacheHit +add wave -noupdate -expand -group lsu -group dcache -group status /testbench/dut/hart/lsu/dcache/FetchCount +add wave -noupdate -expand -group lsu -group dcache -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBPAdr +add wave -noupdate -expand -group lsu -group dcache -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBRead +add wave -noupdate -expand -group lsu -group dcache -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBWrite +add wave -noupdate -expand -group lsu -group dcache -group {Memory Side} /testbench/dut/hart/lsu/dcache/AHBAck +add wave -noupdate -expand -group lsu -group dcache -group {Memory Side} /testbench/dut/hart/lsu/dcache/HRDATA +add wave -noupdate -expand -group lsu -group dcache -group {Memory Side} /testbench/dut/hart/lsu/dcache/HWDATA +add wave -noupdate -expand -group lsu -group dcache /testbench/dut/hart/lsu/dcache/FlushWay add wave -noupdate -expand -group lsu -group dtlb /testbench/dut/hart/lsu/dmmu/genblk1/tlb/tlbcontrol/EffectivePrivilegeMode add wave -noupdate -expand -group lsu -group dtlb /testbench/dut/hart/lsu/dmmu/genblk1/tlb/tlbcontrol/Translate add wave -noupdate -expand -group lsu -group dtlb /testbench/dut/hart/lsu/dmmu/genblk1/tlb/tlbcontrol/DisableTranslation @@ -383,19 +382,19 @@ add wave -noupdate -expand -group lsu -group pma /testbench/dut/hart/lsu/dmmu/PM add wave -noupdate -expand -group lsu -group pmp /testbench/dut/hart/lsu/dmmu/PMPInstrAccessFaultF add wave -noupdate -expand -group lsu -group pmp /testbench/dut/hart/lsu/dmmu/PMPLoadAccessFaultM add wave -noupdate -expand -group lsu -group pmp /testbench/dut/hart/lsu/dmmu/PMPStoreAccessFaultM -add wave -noupdate -expand -group lsu -group ptwalker -color Gold /testbench/dut/hart/lsu/hptw/genblk1/WalkerState -add wave -noupdate -expand -group lsu -group ptwalker /testbench/dut/hart/lsu/hptw/PCF -add wave -noupdate -expand -group lsu -group ptwalker /testbench/dut/hart/lsu/hptw/genblk1/TranslationVAdr -add wave -noupdate -expand -group lsu -group ptwalker /testbench/dut/hart/lsu/hptw/TranslationPAdr -add wave -noupdate -expand -group lsu -group ptwalker /testbench/dut/hart/lsu/hptw/HPTWReadPTE -add wave -noupdate -expand -group lsu -group ptwalker /testbench/dut/hart/lsu/hptw/PTE -add wave -noupdate -expand -group lsu -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/ITLBMissF -add wave -noupdate -expand -group lsu -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/DTLBMissM -add wave -noupdate -expand -group lsu -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/ITLBWriteF -add wave -noupdate -expand -group lsu -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/DTLBWriteM -add wave -noupdate -expand -group lsu -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/WalkerInstrPageFaultF -add wave -noupdate -expand -group lsu -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/WalkerLoadPageFaultM -add wave -noupdate -expand -group lsu -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/WalkerStorePageFaultM +add wave -noupdate -expand -group lsu -expand -group ptwalker -color Gold /testbench/dut/hart/lsu/hptw/genblk1/WalkerState +add wave -noupdate -expand -group lsu -expand -group ptwalker /testbench/dut/hart/lsu/hptw/PCF +add wave -noupdate -expand -group lsu -expand -group ptwalker /testbench/dut/hart/lsu/hptw/genblk1/TranslationVAdr +add wave -noupdate -expand -group lsu -expand -group ptwalker /testbench/dut/hart/lsu/hptw/TranslationPAdr +add wave -noupdate -expand -group lsu -expand -group ptwalker /testbench/dut/hart/lsu/hptw/HPTWReadPTE +add wave -noupdate -expand -group lsu -expand -group ptwalker /testbench/dut/hart/lsu/hptw/PTE +add wave -noupdate -expand -group lsu -expand -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/ITLBMissF +add wave -noupdate -expand -group lsu -expand -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/DTLBMissM +add wave -noupdate -expand -group lsu -expand -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/ITLBWriteF +add wave -noupdate -expand -group lsu -expand -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/DTLBWriteM +add wave -noupdate -expand -group lsu -expand -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/WalkerInstrPageFaultF +add wave -noupdate -expand -group lsu -expand -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/WalkerLoadPageFaultM +add wave -noupdate -expand -group lsu -expand -group ptwalker -expand -group types /testbench/dut/hart/lsu/hptw/WalkerStorePageFaultM add wave -noupdate -group csr -color Gray90 -radix unsigned /testbench/dut/hart/priv/csr/genblk1/counters/genblk1/INSTRET_REGW add wave -noupdate -group csr /testbench/dut/hart/priv/csr/genblk1/counters/genblk1/HPMCOUNTER_REGW add wave -noupdate -group csr -expand -group machine /testbench/dut/hart/priv/csr/genblk1/csrm/MIE_REGW @@ -516,8 +515,8 @@ add wave -noupdate /testbench/dut/uncore/dtim/memwrite add wave -noupdate /testbench/dut/uncore/dtim/HWDATA add wave -noupdate /testbench/dut/uncore/dtim/risingHREADYTim TreeUpdate [SetDefaultTree] -WaveRestoreCursors {{Cursor 23} {209183247 ns} 0} {{Cursor 9} {209026335 ns} 0} -quietly wave cursor active 1 +WaveRestoreCursors {{Cursor 23} {209183247 ns} 0} {{Cursor 5} {37454355 ns} 0} +quietly wave cursor active 2 configure wave -namecolwidth 250 configure wave -valuecolwidth 314 configure wave -justifyvalue left @@ -532,4 +531,4 @@ configure wave -griddelta 40 configure wave -timeline 0 configure wave -timelineunits ns update -WaveRestoreZoom {209183151 ns} {209183343 ns} +WaveRestoreZoom {37454022 ns} {37455158 ns} From 6dd85b80a20691ad1779719d68692c93d2693c2f Mon Sep 17 00:00:00 2001 From: David Harris Date: Thu, 7 Oct 2021 23:03:45 -0400 Subject: [PATCH 016/118] Included TestFloat and SoftFloat --- .../testbench/fp/SoftFloat-3e/COPYING.txt | 37 + .../testbench/fp/SoftFloat-3e/README.html | 49 + .../testbench/fp/SoftFloat-3e/README.txt | 21 + .../SoftFloat-3e/build/Linux-386-GCC/Makefile | 325 + .../build/Linux-386-GCC/platform.h | 53 + .../build/Linux-386-SSE2-GCC/Makefile | 325 + .../build/Linux-386-SSE2-GCC/platform.h | 53 + .../build/Linux-ARM-VFPv2-GCC/Makefile | 323 + .../build/Linux-ARM-VFPv2-GCC/platform.h | 53 + .../build/Linux-x86_64-GCC/Makefile | 390 ++ .../build/Linux-x86_64-GCC/platform.h | 54 + .../SoftFloat-3e/build/Win32-MinGW/Makefile | 325 + .../SoftFloat-3e/build/Win32-MinGW/platform.h | 53 + .../build/Win32-SSE2-MinGW/Makefile | 325 + .../build/Win32-SSE2-MinGW/platform.h | 53 + .../build/Win64-MinGW-w64/Makefile | 390 ++ .../build/Win64-MinGW-w64/platform.h | 54 + .../build/template-FAST_INT64/Makefile | 391 ++ .../build/template-FAST_INT64/platform.h | 50 + .../build/template-not-FAST_INT64/Makefile | 325 + .../build/template-not-FAST_INT64/platform.h | 50 + .../SoftFloat-3e/doc/SoftFloat-history.html | 258 + .../fp/SoftFloat-3e/doc/SoftFloat-source.html | 686 +++ .../fp/SoftFloat-3e/doc/SoftFloat.html | 1527 +++++ .../source/8086-SSE/extF80M_isSignalingNaN.c | 57 + .../source/8086-SSE/f128M_isSignalingNaN.c | 60 + .../source/8086-SSE/s_commonNaNToExtF80M.c | 56 + .../source/8086-SSE/s_commonNaNToExtF80UI.c | 56 + .../source/8086-SSE/s_commonNaNToF128M.c | 56 + .../source/8086-SSE/s_commonNaNToF128UI.c | 55 + .../source/8086-SSE/s_commonNaNToF16UI.c | 51 + .../source/8086-SSE/s_commonNaNToF32UI.c | 51 + .../source/8086-SSE/s_commonNaNToF64UI.c | 53 + .../source/8086-SSE/s_extF80MToCommonNaN.c | 62 + .../source/8086-SSE/s_extF80UIToCommonNaN.c | 62 + .../source/8086-SSE/s_f128MToCommonNaN.c | 62 + .../source/8086-SSE/s_f128UIToCommonNaN.c | 65 + .../source/8086-SSE/s_f16UIToCommonNaN.c | 59 + .../source/8086-SSE/s_f32UIToCommonNaN.c | 59 + .../source/8086-SSE/s_f64UIToCommonNaN.c | 59 + .../source/8086-SSE/s_propagateNaNExtF80M.c | 107 + .../source/8086-SSE/s_propagateNaNExtF80UI.c | 106 + .../source/8086-SSE/s_propagateNaNF128M.c | 76 + .../source/8086-SSE/s_propagateNaNF128UI.c | 81 + .../source/8086-SSE/s_propagateNaNF16UI.c | 63 + .../source/8086-SSE/s_propagateNaNF32UI.c | 63 + .../source/8086-SSE/s_propagateNaNF64UI.c | 63 + .../source/8086-SSE/softfloat_raiseFlags.c | 52 + .../SoftFloat-3e/source/8086-SSE/specialize.h | 376 ++ .../source/8086/extF80M_isSignalingNaN.c | 57 + .../source/8086/f128M_isSignalingNaN.c | 60 + .../source/8086/s_commonNaNToExtF80M.c | 56 + .../source/8086/s_commonNaNToExtF80UI.c | 56 + .../source/8086/s_commonNaNToF128M.c | 56 + .../source/8086/s_commonNaNToF128UI.c | 55 + .../source/8086/s_commonNaNToF16UI.c | 51 + .../source/8086/s_commonNaNToF32UI.c | 51 + .../source/8086/s_commonNaNToF64UI.c | 53 + .../source/8086/s_extF80MToCommonNaN.c | 62 + .../source/8086/s_extF80UIToCommonNaN.c | 62 + .../source/8086/s_f128MToCommonNaN.c | 62 + .../source/8086/s_f128UIToCommonNaN.c | 65 + .../source/8086/s_f16UIToCommonNaN.c | 59 + .../source/8086/s_f32UIToCommonNaN.c | 59 + .../source/8086/s_f64UIToCommonNaN.c | 59 + .../source/8086/s_propagateNaNExtF80M.c | 107 + .../source/8086/s_propagateNaNExtF80UI.c | 106 + .../source/8086/s_propagateNaNF128M.c | 108 + .../source/8086/s_propagateNaNF128UI.c | 105 + .../source/8086/s_propagateNaNF16UI.c | 84 + .../source/8086/s_propagateNaNF32UI.c | 84 + .../source/8086/s_propagateNaNF64UI.c | 84 + .../source/8086/softfloat_raiseFlags.c | 52 + .../fp/SoftFloat-3e/source/8086/specialize.h | 376 ++ .../extF80M_isSignalingNaN.c | 57 + .../f128M_isSignalingNaN.c | 60 + .../s_commonNaNToExtF80M.c | 57 + .../s_commonNaNToExtF80UI.c | 57 + .../ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c | 60 + .../s_commonNaNToF128UI.c | 56 + .../ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c | 5 + .../ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c | 5 + .../ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c | 5 + .../s_extF80MToCommonNaN.c | 5 + .../s_extF80UIToCommonNaN.c | 5 + .../ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c | 5 + .../s_f128UIToCommonNaN.c | 5 + .../ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c | 5 + .../ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c | 5 + .../ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c | 5 + .../s_propagateNaNExtF80M.c | 74 + .../s_propagateNaNExtF80UI.c | 73 + .../s_propagateNaNF128M.c | 68 + .../s_propagateNaNF128UI.c | 73 + .../s_propagateNaNF16UI.c | 58 + .../s_propagateNaNF32UI.c | 58 + .../s_propagateNaNF64UI.c | 58 + .../softfloat_raiseFlags.c | 52 + .../source/ARM-VFPv2-defaultNaN/specialize.h | 407 ++ .../source/ARM-VFPv2/extF80M_isSignalingNaN.c | 57 + .../source/ARM-VFPv2/f128M_isSignalingNaN.c | 60 + .../source/ARM-VFPv2/s_commonNaNToExtF80M.c | 56 + .../source/ARM-VFPv2/s_commonNaNToExtF80UI.c | 56 + .../source/ARM-VFPv2/s_commonNaNToF128M.c | 56 + .../source/ARM-VFPv2/s_commonNaNToF128UI.c | 55 + .../source/ARM-VFPv2/s_commonNaNToF16UI.c | 51 + .../source/ARM-VFPv2/s_commonNaNToF32UI.c | 51 + .../source/ARM-VFPv2/s_commonNaNToF64UI.c | 53 + .../source/ARM-VFPv2/s_extF80MToCommonNaN.c | 62 + .../source/ARM-VFPv2/s_extF80UIToCommonNaN.c | 62 + .../source/ARM-VFPv2/s_f128MToCommonNaN.c | 62 + .../source/ARM-VFPv2/s_f128UIToCommonNaN.c | 65 + .../source/ARM-VFPv2/s_f16UIToCommonNaN.c | 59 + .../source/ARM-VFPv2/s_f32UIToCommonNaN.c | 59 + .../source/ARM-VFPv2/s_f64UIToCommonNaN.c | 59 + .../source/ARM-VFPv2/s_propagateNaNExtF80M.c | 86 + .../source/ARM-VFPv2/s_propagateNaNExtF80UI.c | 83 + .../source/ARM-VFPv2/s_propagateNaNF128M.c | 77 + .../source/ARM-VFPv2/s_propagateNaNF128UI.c | 83 + .../source/ARM-VFPv2/s_propagateNaNF16UI.c | 63 + .../source/ARM-VFPv2/s_propagateNaNF32UI.c | 63 + .../source/ARM-VFPv2/s_propagateNaNF64UI.c | 63 + .../source/ARM-VFPv2/softfloat_raiseFlags.c | 52 + .../source/ARM-VFPv2/specialize.h | 376 ++ .../fp/SoftFloat-3e/source/extF80M_add.c | 100 + .../fp/SoftFloat-3e/source/extF80M_div.c | 194 + .../fp/SoftFloat-3e/source/extF80M_eq.c | 98 + .../source/extF80M_eq_signaling.c | 92 + .../fp/SoftFloat-3e/source/extF80M_le.c | 106 + .../fp/SoftFloat-3e/source/extF80M_le_quiet.c | 112 + .../fp/SoftFloat-3e/source/extF80M_lt.c | 106 + .../fp/SoftFloat-3e/source/extF80M_lt_quiet.c | 112 + .../fp/SoftFloat-3e/source/extF80M_mul.c | 139 + .../fp/SoftFloat-3e/source/extF80M_rem.c | 204 + .../SoftFloat-3e/source/extF80M_roundToInt.c | 176 + .../fp/SoftFloat-3e/source/extF80M_sqrt.c | 180 + .../fp/SoftFloat-3e/source/extF80M_sub.c | 100 + .../fp/SoftFloat-3e/source/extF80M_to_f128M.c | 125 + .../fp/SoftFloat-3e/source/extF80M_to_f16.c | 112 + .../fp/SoftFloat-3e/source/extF80M_to_f32.c | 112 + .../fp/SoftFloat-3e/source/extF80M_to_f64.c | 112 + .../fp/SoftFloat-3e/source/extF80M_to_i32.c | 100 + .../source/extF80M_to_i32_r_minMag.c | 120 + .../fp/SoftFloat-3e/source/extF80M_to_i64.c | 97 + .../source/extF80M_to_i64_r_minMag.c | 115 + .../fp/SoftFloat-3e/source/extF80M_to_ui32.c | 101 + .../source/extF80M_to_ui32_r_minMag.c | 111 + .../fp/SoftFloat-3e/source/extF80M_to_ui64.c | 97 + .../source/extF80M_to_ui64_r_minMag.c | 108 + .../fp/SoftFloat-3e/source/extF80_add.c | 80 + .../fp/SoftFloat-3e/source/extF80_div.c | 203 + .../fp/SoftFloat-3e/source/extF80_eq.c | 73 + .../SoftFloat-3e/source/extF80_eq_signaling.c | 67 + .../source/extF80_isSignalingNaN.c | 51 + .../fp/SoftFloat-3e/source/extF80_le.c | 73 + .../fp/SoftFloat-3e/source/extF80_le_quiet.c | 78 + .../fp/SoftFloat-3e/source/extF80_lt.c | 73 + .../fp/SoftFloat-3e/source/extF80_lt_quiet.c | 78 + .../fp/SoftFloat-3e/source/extF80_mul.c | 158 + .../fp/SoftFloat-3e/source/extF80_rem.c | 225 + .../SoftFloat-3e/source/extF80_roundToInt.c | 154 + .../fp/SoftFloat-3e/source/extF80_sqrt.c | 176 + .../fp/SoftFloat-3e/source/extF80_sub.c | 80 + .../fp/SoftFloat-3e/source/extF80_to_f128.c | 75 + .../fp/SoftFloat-3e/source/extF80_to_f16.c | 96 + .../fp/SoftFloat-3e/source/extF80_to_f32.c | 96 + .../fp/SoftFloat-3e/source/extF80_to_f64.c | 96 + .../fp/SoftFloat-3e/source/extF80_to_i32.c | 83 + .../source/extF80_to_i32_r_minMag.c | 97 + .../fp/SoftFloat-3e/source/extF80_to_i64.c | 89 + .../source/extF80_to_i64_r_minMag.c | 94 + .../fp/SoftFloat-3e/source/extF80_to_ui32.c | 83 + .../source/extF80_to_ui32_r_minMag.c | 88 + .../fp/SoftFloat-3e/source/extF80_to_ui64.c | 84 + .../source/extF80_to_ui64_r_minMag.c | 88 + .../fp/SoftFloat-3e/source/f128M_add.c | 97 + .../fp/SoftFloat-3e/source/f128M_div.c | 187 + .../fp/SoftFloat-3e/source/f128M_eq.c | 100 + .../SoftFloat-3e/source/f128M_eq_signaling.c | 92 + .../fp/SoftFloat-3e/source/f128M_le.c | 93 + .../fp/SoftFloat-3e/source/f128M_le_quiet.c | 96 + .../fp/SoftFloat-3e/source/f128M_lt.c | 93 + .../fp/SoftFloat-3e/source/f128M_lt_quiet.c | 96 + .../fp/SoftFloat-3e/source/f128M_mul.c | 158 + .../fp/SoftFloat-3e/source/f128M_mulAdd.c | 92 + .../fp/SoftFloat-3e/source/f128M_rem.c | 182 + .../fp/SoftFloat-3e/source/f128M_roundToInt.c | 223 + .../fp/SoftFloat-3e/source/f128M_sqrt.c | 228 + .../fp/SoftFloat-3e/source/f128M_sub.c | 97 + .../fp/SoftFloat-3e/source/f128M_to_extF80M.c | 101 + .../fp/SoftFloat-3e/source/f128M_to_f16.c | 113 + .../fp/SoftFloat-3e/source/f128M_to_f32.c | 109 + .../fp/SoftFloat-3e/source/f128M_to_f64.c | 112 + .../fp/SoftFloat-3e/source/f128M_to_i32.c | 98 + .../source/f128M_to_i32_r_minMag.c | 106 + .../fp/SoftFloat-3e/source/f128M_to_i64.c | 102 + .../source/f128M_to_i64_r_minMag.c | 124 + .../fp/SoftFloat-3e/source/f128M_to_ui32.c | 98 + .../source/f128M_to_ui32_r_minMag.c | 102 + .../fp/SoftFloat-3e/source/f128M_to_ui64.c | 102 + .../source/f128M_to_ui64_r_minMag.c | 114 + .../fp/SoftFloat-3e/source/f128_add.c | 78 + .../fp/SoftFloat-3e/source/f128_div.c | 199 + .../fp/SoftFloat-3e/source/f128_eq.c | 73 + .../SoftFloat-3e/source/f128_eq_signaling.c | 67 + .../SoftFloat-3e/source/f128_isSignalingNaN.c | 51 + .../fp/SoftFloat-3e/source/f128_le.c | 72 + .../fp/SoftFloat-3e/source/f128_le_quiet.c | 78 + .../fp/SoftFloat-3e/source/f128_lt.c | 72 + .../fp/SoftFloat-3e/source/f128_lt_quiet.c | 78 + .../fp/SoftFloat-3e/source/f128_mul.c | 163 + .../fp/SoftFloat-3e/source/f128_mulAdd.c | 63 + .../fp/SoftFloat-3e/source/f128_rem.c | 190 + .../fp/SoftFloat-3e/source/f128_roundToInt.c | 172 + .../fp/SoftFloat-3e/source/f128_sqrt.c | 201 + .../fp/SoftFloat-3e/source/f128_sub.c | 78 + .../fp/SoftFloat-3e/source/f128_to_extF80.c | 109 + .../fp/SoftFloat-3e/source/f128_to_f16.c | 95 + .../fp/SoftFloat-3e/source/f128_to_f32.c | 95 + .../fp/SoftFloat-3e/source/f128_to_f64.c | 100 + .../fp/SoftFloat-3e/source/f128_to_i32.c | 85 + .../source/f128_to_i32_r_minMag.c | 100 + .../fp/SoftFloat-3e/source/f128_to_i64.c | 95 + .../source/f128_to_i64_r_minMag.c | 113 + .../fp/SoftFloat-3e/source/f128_to_ui32.c | 86 + .../source/f128_to_ui32_r_minMag.c | 89 + .../fp/SoftFloat-3e/source/f128_to_ui64.c | 96 + .../source/f128_to_ui64_r_minMag.c | 105 + .../fp/SoftFloat-3e/source/f16_add.c | 70 + .../fp/SoftFloat-3e/source/f16_div.c | 186 + .../testbench/fp/SoftFloat-3e/source/f16_eq.c | 66 + .../fp/SoftFloat-3e/source/f16_eq_signaling.c | 61 + .../SoftFloat-3e/source/f16_isSignalingNaN.c | 51 + .../testbench/fp/SoftFloat-3e/source/f16_le.c | 66 + .../fp/SoftFloat-3e/source/f16_le_quiet.c | 71 + .../testbench/fp/SoftFloat-3e/source/f16_lt.c | 66 + .../fp/SoftFloat-3e/source/f16_lt_quiet.c | 71 + .../fp/SoftFloat-3e/source/f16_mul.c | 140 + .../fp/SoftFloat-3e/source/f16_mulAdd.c | 60 + .../fp/SoftFloat-3e/source/f16_rem.c | 171 + .../fp/SoftFloat-3e/source/f16_roundToInt.c | 120 + .../fp/SoftFloat-3e/source/f16_sqrt.c | 136 + .../fp/SoftFloat-3e/source/f16_sub.c | 70 + .../fp/SoftFloat-3e/source/f16_to_extF80.c | 101 + .../fp/SoftFloat-3e/source/f16_to_extF80M.c | 111 + .../fp/SoftFloat-3e/source/f16_to_f128.c | 96 + .../fp/SoftFloat-3e/source/f16_to_f128M.c | 111 + .../fp/SoftFloat-3e/source/f16_to_f32.c | 93 + .../fp/SoftFloat-3e/source/f16_to_f64.c | 93 + .../fp/SoftFloat-3e/source/f16_to_i32.c | 87 + .../SoftFloat-3e/source/f16_to_i32_r_minMag.c | 88 + .../fp/SoftFloat-3e/source/f16_to_i64.c | 87 + .../SoftFloat-3e/source/f16_to_i64_r_minMag.c | 88 + .../fp/SoftFloat-3e/source/f16_to_ui32.c | 84 + .../source/f16_to_ui32_r_minMag.c | 87 + .../fp/SoftFloat-3e/source/f16_to_ui64.c | 96 + .../source/f16_to_ui64_r_minMag.c | 87 + .../fp/SoftFloat-3e/source/f32_add.c | 70 + .../fp/SoftFloat-3e/source/f32_div.c | 180 + .../testbench/fp/SoftFloat-3e/source/f32_eq.c | 66 + .../fp/SoftFloat-3e/source/f32_eq_signaling.c | 61 + .../SoftFloat-3e/source/f32_isSignalingNaN.c | 51 + .../testbench/fp/SoftFloat-3e/source/f32_le.c | 66 + .../fp/SoftFloat-3e/source/f32_le_quiet.c | 71 + .../testbench/fp/SoftFloat-3e/source/f32_lt.c | 66 + .../fp/SoftFloat-3e/source/f32_lt_quiet.c | 71 + .../fp/SoftFloat-3e/source/f32_mul.c | 137 + .../fp/SoftFloat-3e/source/f32_mulAdd.c | 60 + .../fp/SoftFloat-3e/source/f32_rem.c | 168 + .../fp/SoftFloat-3e/source/f32_roundToInt.c | 120 + .../fp/SoftFloat-3e/source/f32_sqrt.c | 121 + .../fp/SoftFloat-3e/source/f32_sub.c | 70 + .../fp/SoftFloat-3e/source/f32_to_extF80.c | 101 + .../fp/SoftFloat-3e/source/f32_to_extF80M.c | 111 + .../fp/SoftFloat-3e/source/f32_to_f128.c | 96 + .../fp/SoftFloat-3e/source/f32_to_f128M.c | 115 + .../fp/SoftFloat-3e/source/f32_to_f16.c | 88 + .../fp/SoftFloat-3e/source/f32_to_f64.c | 93 + .../fp/SoftFloat-3e/source/f32_to_i32.c | 84 + .../SoftFloat-3e/source/f32_to_i32_r_minMag.c | 89 + .../fp/SoftFloat-3e/source/f32_to_i64.c | 96 + .../SoftFloat-3e/source/f32_to_i64_r_minMag.c | 94 + .../fp/SoftFloat-3e/source/f32_to_ui32.c | 84 + .../source/f32_to_ui32_r_minMag.c | 88 + .../fp/SoftFloat-3e/source/f32_to_ui64.c | 96 + .../source/f32_to_ui64_r_minMag.c | 90 + .../fp/SoftFloat-3e/source/f64_add.c | 74 + .../fp/SoftFloat-3e/source/f64_div.c | 172 + .../testbench/fp/SoftFloat-3e/source/f64_eq.c | 66 + .../fp/SoftFloat-3e/source/f64_eq_signaling.c | 61 + .../SoftFloat-3e/source/f64_isSignalingNaN.c | 51 + .../testbench/fp/SoftFloat-3e/source/f64_le.c | 67 + .../fp/SoftFloat-3e/source/f64_le_quiet.c | 72 + .../testbench/fp/SoftFloat-3e/source/f64_lt.c | 67 + .../fp/SoftFloat-3e/source/f64_lt_quiet.c | 72 + .../fp/SoftFloat-3e/source/f64_mul.c | 150 + .../fp/SoftFloat-3e/source/f64_mulAdd.c | 60 + .../fp/SoftFloat-3e/source/f64_rem.c | 189 + .../fp/SoftFloat-3e/source/f64_roundToInt.c | 120 + .../fp/SoftFloat-3e/source/f64_sqrt.c | 133 + .../fp/SoftFloat-3e/source/f64_sub.c | 74 + .../fp/SoftFloat-3e/source/f64_to_extF80.c | 101 + .../fp/SoftFloat-3e/source/f64_to_extF80M.c | 111 + .../fp/SoftFloat-3e/source/f64_to_f128.c | 98 + .../fp/SoftFloat-3e/source/f64_to_f128M.c | 117 + .../fp/SoftFloat-3e/source/f64_to_f16.c | 88 + .../fp/SoftFloat-3e/source/f64_to_f32.c | 88 + .../fp/SoftFloat-3e/source/f64_to_i32.c | 82 + .../SoftFloat-3e/source/f64_to_i32_r_minMag.c | 96 + .../fp/SoftFloat-3e/source/f64_to_i64.c | 103 + .../SoftFloat-3e/source/f64_to_i64_r_minMag.c | 100 + .../fp/SoftFloat-3e/source/f64_to_ui32.c | 82 + .../source/f64_to_ui32_r_minMag.c | 88 + .../fp/SoftFloat-3e/source/f64_to_ui64.c | 103 + .../source/f64_to_ui64_r_minMag.c | 93 + .../fp/SoftFloat-3e/source/i32_to_extF80.c | 65 + .../fp/SoftFloat-3e/source/i32_to_extF80M.c | 78 + .../fp/SoftFloat-3e/source/i32_to_f128.c | 64 + .../fp/SoftFloat-3e/source/i32_to_f128M.c | 81 + .../fp/SoftFloat-3e/source/i32_to_f16.c | 71 + .../fp/SoftFloat-3e/source/i32_to_f32.c | 58 + .../fp/SoftFloat-3e/source/i32_to_f64.c | 65 + .../fp/SoftFloat-3e/source/i64_to_extF80.c | 65 + .../fp/SoftFloat-3e/source/i64_to_extF80M.c | 78 + .../fp/SoftFloat-3e/source/i64_to_f128.c | 72 + .../fp/SoftFloat-3e/source/i64_to_f128M.c | 92 + .../fp/SoftFloat-3e/source/i64_to_f16.c | 70 + .../fp/SoftFloat-3e/source/i64_to_f32.c | 70 + .../fp/SoftFloat-3e/source/i64_to_f64.c | 58 + .../SoftFloat-3e/source/include/internals.h | 278 + .../fp/SoftFloat-3e/source/include/opts-GCC.h | 114 + .../source/include/primitiveTypes.h | 85 + .../SoftFloat-3e/source/include/primitives.h | 1160 ++++ .../SoftFloat-3e/source/include/softfloat.h | 372 ++ .../source/include/softfloat_types.h | 81 + .../fp/SoftFloat-3e/source/s_add128.c | 55 + .../fp/SoftFloat-3e/source/s_add256M.c | 65 + .../fp/SoftFloat-3e/source/s_addCarryM.c | 70 + .../fp/SoftFloat-3e/source/s_addComplCarryM.c | 70 + .../fp/SoftFloat-3e/source/s_addExtF80M.c | 186 + .../fp/SoftFloat-3e/source/s_addF128M.c | 211 + .../testbench/fp/SoftFloat-3e/source/s_addM.c | 70 + .../fp/SoftFloat-3e/source/s_addMagsExtF80.c | 156 + .../fp/SoftFloat-3e/source/s_addMagsF128.c | 154 + .../fp/SoftFloat-3e/source/s_addMagsF16.c | 183 + .../fp/SoftFloat-3e/source/s_addMagsF32.c | 126 + .../fp/SoftFloat-3e/source/s_addMagsF64.c | 128 + .../SoftFloat-3e/source/s_approxRecip32_1.c | 66 + .../source/s_approxRecipSqrt32_1.c | 73 + .../source/s_approxRecipSqrt_1Ks.c | 49 + .../SoftFloat-3e/source/s_approxRecip_1Ks.c | 49 + .../fp/SoftFloat-3e/source/s_compare128M.c | 62 + .../fp/SoftFloat-3e/source/s_compare96M.c | 62 + .../source/s_compareNonnormExtF80M.c | 111 + .../source/s_countLeadingZeros16.c | 60 + .../source/s_countLeadingZeros32.c | 64 + .../source/s_countLeadingZeros64.c | 73 + .../source/s_countLeadingZeros8.c | 59 + .../fp/SoftFloat-3e/source/s_eq128.c | 51 + .../fp/SoftFloat-3e/source/s_invalidExtF80M.c | 49 + .../fp/SoftFloat-3e/source/s_invalidF128M.c | 53 + .../fp/SoftFloat-3e/source/s_isNaNF128M.c | 57 + .../fp/SoftFloat-3e/source/s_le128.c | 51 + .../fp/SoftFloat-3e/source/s_lt128.c | 51 + .../fp/SoftFloat-3e/source/s_mul128By32.c | 58 + .../fp/SoftFloat-3e/source/s_mul128MTo256M.c | 100 + .../fp/SoftFloat-3e/source/s_mul128To256M.c | 71 + .../source/s_mul64ByShifted32To128.c | 56 + .../fp/SoftFloat-3e/source/s_mul64To128.c | 66 + .../fp/SoftFloat-3e/source/s_mul64To128M.c | 68 + .../fp/SoftFloat-3e/source/s_mulAddF128.c | 350 ++ .../fp/SoftFloat-3e/source/s_mulAddF128M.c | 382 ++ .../fp/SoftFloat-3e/source/s_mulAddF16.c | 226 + .../fp/SoftFloat-3e/source/s_mulAddF32.c | 224 + .../fp/SoftFloat-3e/source/s_mulAddF64.c | 496 ++ .../fp/SoftFloat-3e/source/s_negXM.c | 63 + .../fp/SoftFloat-3e/source/s_normExtF80SigM.c | 52 + .../source/s_normRoundPackMToExtF80M.c | 78 + .../source/s_normRoundPackMToF128M.c | 73 + .../source/s_normRoundPackToExtF80.c | 71 + .../source/s_normRoundPackToF128.c | 81 + .../source/s_normRoundPackToF16.c | 58 + .../source/s_normRoundPackToF32.c | 58 + .../source/s_normRoundPackToF64.c | 58 + .../source/s_normSubnormalExtF80Sig.c | 52 + .../source/s_normSubnormalF128Sig.c | 65 + .../source/s_normSubnormalF128SigM.c | 61 + .../source/s_normSubnormalF16Sig.c | 52 + .../source/s_normSubnormalF32Sig.c | 52 + .../source/s_normSubnormalF64Sig.c | 52 + .../fp/SoftFloat-3e/source/s_remStepMBy32.c | 86 + .../fp/SoftFloat-3e/source/s_roundMToI64.c | 102 + .../fp/SoftFloat-3e/source/s_roundMToUI64.c | 98 + .../source/s_roundPackMToExtF80M.c | 256 + .../SoftFloat-3e/source/s_roundPackMToF128M.c | 178 + .../SoftFloat-3e/source/s_roundPackToExtF80.c | 256 + .../SoftFloat-3e/source/s_roundPackToF128.c | 171 + .../fp/SoftFloat-3e/source/s_roundPackToF16.c | 113 + .../fp/SoftFloat-3e/source/s_roundPackToF32.c | 113 + .../fp/SoftFloat-3e/source/s_roundPackToF64.c | 117 + .../fp/SoftFloat-3e/source/s_roundToI32.c | 98 + .../fp/SoftFloat-3e/source/s_roundToI64.c | 101 + .../fp/SoftFloat-3e/source/s_roundToUI32.c | 93 + .../fp/SoftFloat-3e/source/s_roundToUI64.c | 97 + .../fp/SoftFloat-3e/source/s_shiftLeftM.c | 91 + .../SoftFloat-3e/source/s_shiftNormSigF128M.c | 78 + .../SoftFloat-3e/source/s_shiftRightJam128.c | 69 + .../source/s_shiftRightJam128Extra.c | 77 + .../SoftFloat-3e/source/s_shiftRightJam256M.c | 126 + .../SoftFloat-3e/source/s_shiftRightJam32.c | 51 + .../SoftFloat-3e/source/s_shiftRightJam64.c | 51 + .../source/s_shiftRightJam64Extra.c | 62 + .../fp/SoftFloat-3e/source/s_shiftRightJamM.c | 101 + .../fp/SoftFloat-3e/source/s_shiftRightM.c | 91 + .../SoftFloat-3e/source/s_shortShiftLeft128.c | 55 + .../source/s_shortShiftLeft64To96M.c | 56 + .../SoftFloat-3e/source/s_shortShiftLeftM.c | 70 + .../source/s_shortShiftRight128.c | 55 + .../source/s_shortShiftRightExtendM.c | 73 + .../source/s_shortShiftRightJam128.c | 60 + .../source/s_shortShiftRightJam128Extra.c | 59 + .../source/s_shortShiftRightJam64.c | 50 + .../source/s_shortShiftRightJam64Extra.c | 56 + .../source/s_shortShiftRightJamM.c | 72 + .../SoftFloat-3e/source/s_shortShiftRightM.c | 70 + .../fp/SoftFloat-3e/source/s_sub128.c | 55 + .../fp/SoftFloat-3e/source/s_sub1XM.c | 60 + .../fp/SoftFloat-3e/source/s_sub256M.c | 65 + .../testbench/fp/SoftFloat-3e/source/s_subM.c | 70 + .../fp/SoftFloat-3e/source/s_subMagsExtF80.c | 158 + .../fp/SoftFloat-3e/source/s_subMagsF128.c | 139 + .../fp/SoftFloat-3e/source/s_subMagsF16.c | 187 + .../fp/SoftFloat-3e/source/s_subMagsF32.c | 143 + .../fp/SoftFloat-3e/source/s_subMagsF64.c | 141 + .../source/s_tryPropagateNaNExtF80M.c | 64 + .../source/s_tryPropagateNaNF128M.c | 55 + .../fp/SoftFloat-3e/source/softfloat_state.c | 52 + .../fp/SoftFloat-3e/source/ui32_to_extF80.c | 59 + .../fp/SoftFloat-3e/source/ui32_to_extF80M.c | 74 + .../fp/SoftFloat-3e/source/ui32_to_f128.c | 60 + .../fp/SoftFloat-3e/source/ui32_to_f128M.c | 76 + .../fp/SoftFloat-3e/source/ui32_to_f16.c | 65 + .../fp/SoftFloat-3e/source/ui32_to_f32.c | 57 + .../fp/SoftFloat-3e/source/ui32_to_f64.c | 59 + .../fp/SoftFloat-3e/source/ui64_to_extF80.c | 59 + .../fp/SoftFloat-3e/source/ui64_to_extF80M.c | 74 + .../fp/SoftFloat-3e/source/ui64_to_f128.c | 68 + .../fp/SoftFloat-3e/source/ui64_to_f128M.c | 86 + .../fp/SoftFloat-3e/source/ui64_to_f16.c | 64 + .../fp/SoftFloat-3e/source/ui64_to_f32.c | 64 + .../fp/SoftFloat-3e/source/ui64_to_f64.c | 59 + .../testbench/fp/TestFloat-3e/COPYING.txt | 37 + .../testbench/fp/TestFloat-3e/README.html | 82 + .../testbench/fp/TestFloat-3e/README.txt | 26 + .../TestFloat-3e/build/Linux-386-GCC/Makefile | 355 ++ .../build/Linux-386-GCC/platform.h | 49 + .../build/Linux-386-SSE2-GCC/Makefile | 355 ++ .../build/Linux-386-SSE2-GCC/platform.h | 49 + .../build/Linux-ARM-VFPv2-GCC/Makefile | 353 ++ .../build/Linux-ARM-VFPv2-GCC/platform.h | 49 + .../build/Linux-x86_64-GCC/Makefile | 355 ++ .../build/Linux-x86_64-GCC/platform.h | 49 + .../TestFloat-3e/build/Win32-MinGW/Makefile | 355 ++ .../TestFloat-3e/build/Win32-MinGW/platform.h | 49 + .../build/Win32-SSE2-MinGW/Makefile | 355 ++ .../build/Win32-SSE2-MinGW/platform.h | 49 + .../build/Win64-MinGW-w64/Makefile | 355 ++ .../build/Win64-MinGW-w64/platform.h | 49 + .../fp/TestFloat-3e/build/template/Makefile | 353 ++ .../fp/TestFloat-3e/build/template/platform.h | 51 + .../TestFloat-3e/doc/TestFloat-general.html | 1148 ++++ .../TestFloat-3e/doc/TestFloat-history.html | 272 + .../fp/TestFloat-3e/doc/TestFloat-source.html | 639 ++ .../fp/TestFloat-3e/doc/testfloat.html | 286 + .../fp/TestFloat-3e/doc/testfloat_gen.html | 367 ++ .../fp/TestFloat-3e/doc/testfloat_ver.html | 270 + .../fp/TestFloat-3e/doc/testsoftfloat.html | 236 + .../fp/TestFloat-3e/doc/timesoftfloat.html | 196 + .../testbench/fp/TestFloat-3e/source/fail.c | 59 + .../testbench/fp/TestFloat-3e/source/fail.h | 41 + .../fp/TestFloat-3e/source/functionInfos.c | 290 + .../fp/TestFloat-3e/source/functions.h | 324 + .../fp/TestFloat-3e/source/functions_common.c | 60 + .../fp/TestFloat-3e/source/genCases.h | 114 + .../fp/TestFloat-3e/source/genCases_common.c | 58 + .../fp/TestFloat-3e/source/genCases_extF80.c | 920 +++ .../fp/TestFloat-3e/source/genCases_f128.c | 1090 ++++ .../fp/TestFloat-3e/source/genCases_f16.c | 585 ++ .../fp/TestFloat-3e/source/genCases_f32.c | 664 +++ .../fp/TestFloat-3e/source/genCases_f64.c | 808 +++ .../fp/TestFloat-3e/source/genCases_i32.c | 362 ++ .../fp/TestFloat-3e/source/genCases_i64.c | 554 ++ .../fp/TestFloat-3e/source/genCases_ui32.c | 323 + .../fp/TestFloat-3e/source/genCases_ui64.c | 483 ++ .../source/genCases_writeTestsTotal.c | 63 + .../fp/TestFloat-3e/source/genLoops.c | 2890 +++++++++ .../fp/TestFloat-3e/source/genLoops.h | 354 ++ .../testbench/fp/TestFloat-3e/source/random.c | 138 + .../testbench/fp/TestFloat-3e/source/random.h | 49 + .../fp/TestFloat-3e/source/readHex.c | 190 + .../fp/TestFloat-3e/source/readHex.h | 46 + .../fp/TestFloat-3e/source/slowfloat.c | 3749 ++++++++++++ .../fp/TestFloat-3e/source/slowfloat.h | 298 + .../source/standardFunctionInfos.c | 471 ++ .../fp/TestFloat-3e/source/subj-C/subjfloat.c | 856 +++ .../source/subj-C/subjfloat_config.h | 133 + .../fp/TestFloat-3e/source/subjfloat.h | 516 ++ .../TestFloat-3e/source/subjfloat_functions.c | 1810 ++++++ .../fp/TestFloat-3e/source/testLoops.h | 578 ++ .../fp/TestFloat-3e/source/testLoops_common.c | 47 + .../source/test_a_extF80_z_f128.c | 107 + .../TestFloat-3e/source/test_a_extF80_z_f16.c | 107 + .../TestFloat-3e/source/test_a_extF80_z_f32.c | 107 + .../TestFloat-3e/source/test_a_extF80_z_f64.c | 107 + .../source/test_a_extF80_z_i32_rx.c | 105 + .../source/test_a_extF80_z_i32_x.c | 104 + .../source/test_a_extF80_z_i64_rx.c | 106 + .../source/test_a_extF80_z_i64_x.c | 105 + .../source/test_a_extF80_z_ui32_rx.c | 103 + .../source/test_a_extF80_z_ui32_x.c | 102 + .../source/test_a_extF80_z_ui64_rx.c | 103 + .../source/test_a_extF80_z_ui64_x.c | 102 + .../source/test_a_f128_z_extF80.c | 107 + .../TestFloat-3e/source/test_a_f128_z_f16.c | 107 + .../TestFloat-3e/source/test_a_f128_z_f32.c | 107 + .../TestFloat-3e/source/test_a_f128_z_f64.c | 107 + .../source/test_a_f128_z_i32_rx.c | 104 + .../TestFloat-3e/source/test_a_f128_z_i32_x.c | 103 + .../source/test_a_f128_z_i64_rx.c | 105 + .../TestFloat-3e/source/test_a_f128_z_i64_x.c | 104 + .../source/test_a_f128_z_ui32_rx.c | 103 + .../source/test_a_f128_z_ui32_x.c | 102 + .../source/test_a_f128_z_ui64_rx.c | 103 + .../source/test_a_f128_z_ui64_x.c | 102 + .../TestFloat-3e/source/test_a_f16_z_extF80.c | 106 + .../TestFloat-3e/source/test_a_f16_z_f128.c | 106 + .../fp/TestFloat-3e/source/test_a_f16_z_f32.c | 104 + .../fp/TestFloat-3e/source/test_a_f16_z_f64.c | 104 + .../TestFloat-3e/source/test_a_f16_z_i32_rx.c | 104 + .../TestFloat-3e/source/test_a_f16_z_i32_x.c | 103 + .../TestFloat-3e/source/test_a_f16_z_i64_rx.c | 105 + .../TestFloat-3e/source/test_a_f16_z_i64_x.c | 104 + .../source/test_a_f16_z_ui32_rx.c | 103 + .../TestFloat-3e/source/test_a_f16_z_ui32_x.c | 102 + .../source/test_a_f16_z_ui64_rx.c | 103 + .../TestFloat-3e/source/test_a_f16_z_ui64_x.c | 102 + .../TestFloat-3e/source/test_a_f32_z_extF80.c | 106 + .../TestFloat-3e/source/test_a_f32_z_f128.c | 106 + .../fp/TestFloat-3e/source/test_a_f32_z_f16.c | 104 + .../fp/TestFloat-3e/source/test_a_f32_z_f64.c | 104 + .../TestFloat-3e/source/test_a_f32_z_i32_rx.c | 100 + .../TestFloat-3e/source/test_a_f32_z_i32_x.c | 99 + .../TestFloat-3e/source/test_a_f32_z_i64_rx.c | 101 + .../TestFloat-3e/source/test_a_f32_z_i64_x.c | 100 + .../source/test_a_f32_z_ui32_rx.c | 99 + .../TestFloat-3e/source/test_a_f32_z_ui32_x.c | 98 + .../source/test_a_f32_z_ui64_rx.c | 99 + .../TestFloat-3e/source/test_a_f32_z_ui64_x.c | 98 + .../TestFloat-3e/source/test_a_f64_z_extF80.c | 106 + .../TestFloat-3e/source/test_a_f64_z_f128.c | 106 + .../fp/TestFloat-3e/source/test_a_f64_z_f16.c | 104 + .../fp/TestFloat-3e/source/test_a_f64_z_f32.c | 104 + .../TestFloat-3e/source/test_a_f64_z_i32_rx.c | 104 + .../TestFloat-3e/source/test_a_f64_z_i32_x.c | 103 + .../TestFloat-3e/source/test_a_f64_z_i64_rx.c | 105 + .../TestFloat-3e/source/test_a_f64_z_i64_x.c | 104 + .../source/test_a_f64_z_ui32_rx.c | 103 + .../TestFloat-3e/source/test_a_f64_z_ui32_x.c | 102 + .../source/test_a_f64_z_ui64_rx.c | 103 + .../TestFloat-3e/source/test_a_f64_z_ui64_x.c | 102 + .../TestFloat-3e/source/test_a_i32_z_extF80.c | 101 + .../TestFloat-3e/source/test_a_i32_z_f128.c | 101 + .../fp/TestFloat-3e/source/test_a_i32_z_f16.c | 99 + .../fp/TestFloat-3e/source/test_a_i32_z_f32.c | 95 + .../fp/TestFloat-3e/source/test_a_i32_z_f64.c | 99 + .../TestFloat-3e/source/test_a_i64_z_extF80.c | 101 + .../TestFloat-3e/source/test_a_i64_z_f128.c | 101 + .../fp/TestFloat-3e/source/test_a_i64_z_f16.c | 99 + .../fp/TestFloat-3e/source/test_a_i64_z_f32.c | 95 + .../fp/TestFloat-3e/source/test_a_i64_z_f64.c | 99 + .../source/test_a_ui32_z_extF80.c | 101 + .../TestFloat-3e/source/test_a_ui32_z_f128.c | 101 + .../TestFloat-3e/source/test_a_ui32_z_f16.c | 99 + .../TestFloat-3e/source/test_a_ui32_z_f32.c | 95 + .../TestFloat-3e/source/test_a_ui32_z_f64.c | 99 + .../source/test_a_ui64_z_extF80.c | 101 + .../TestFloat-3e/source/test_a_ui64_z_f128.c | 101 + .../TestFloat-3e/source/test_a_ui64_z_f16.c | 99 + .../TestFloat-3e/source/test_a_ui64_z_f32.c | 95 + .../TestFloat-3e/source/test_a_ui64_z_f64.c | 99 + .../source/test_ab_extF80_z_bool.c | 104 + .../TestFloat-3e/source/test_ab_f128_z_bool.c | 103 + .../TestFloat-3e/source/test_ab_f16_z_bool.c | 103 + .../TestFloat-3e/source/test_ab_f32_z_bool.c | 99 + .../TestFloat-3e/source/test_ab_f64_z_bool.c | 103 + .../fp/TestFloat-3e/source/test_abcz_f128.c | 125 + .../fp/TestFloat-3e/source/test_abcz_f16.c | 111 + .../fp/TestFloat-3e/source/test_abcz_f32.c | 107 + .../fp/TestFloat-3e/source/test_abcz_f64.c | 111 + .../fp/TestFloat-3e/source/test_abz_extF80.c | 113 + .../fp/TestFloat-3e/source/test_abz_f128.c | 108 + .../fp/TestFloat-3e/source/test_abz_f16.c | 108 + .../fp/TestFloat-3e/source/test_abz_f32.c | 104 + .../fp/TestFloat-3e/source/test_abz_f64.c | 108 + .../fp/TestFloat-3e/source/test_az_extF80.c | 107 + .../TestFloat-3e/source/test_az_extF80_rx.c | 112 + .../fp/TestFloat-3e/source/test_az_f128.c | 107 + .../fp/TestFloat-3e/source/test_az_f128_rx.c | 110 + .../fp/TestFloat-3e/source/test_az_f16.c | 104 + .../fp/TestFloat-3e/source/test_az_f16_rx.c | 109 + .../fp/TestFloat-3e/source/test_az_f32.c | 100 + .../fp/TestFloat-3e/source/test_az_f32_rx.c | 105 + .../fp/TestFloat-3e/source/test_az_f64.c | 104 + .../fp/TestFloat-3e/source/test_az_f64_rx.c | 109 + .../fp/TestFloat-3e/source/testfloat.c | 1715 ++++++ .../fp/TestFloat-3e/source/testfloat_gen.c | 953 +++ .../fp/TestFloat-3e/source/testfloat_ver.c | 795 +++ .../fp/TestFloat-3e/source/testsoftfloat.c | 1127 ++++ .../fp/TestFloat-3e/source/timesoftfloat.c | 5060 ++++++++++++++++ .../fp/TestFloat-3e/source/uint128.c | 99 + .../fp/TestFloat-3e/source/uint128.h | 76 + .../fp/TestFloat-3e/source/uint128_inline.c | 56 + .../fp/TestFloat-3e/source/verCases.h | 193 + .../fp/TestFloat-3e/source/verCases_common.c | 138 + .../fp/TestFloat-3e/source/verCases_inline.c | 138 + .../source/verCases_writeFunctionName.c | 79 + .../fp/TestFloat-3e/source/verLoops.c | 5283 +++++++++++++++++ .../fp/TestFloat-3e/source/verLoops.h | 320 + .../fp/TestFloat-3e/source/writeCase.h | 97 + .../TestFloat-3e/source/writeCase_a_extF80M.c | 55 + .../TestFloat-3e/source/writeCase_a_f128M.c | 55 + .../fp/TestFloat-3e/source/writeCase_a_f16.c | 55 + .../fp/TestFloat-3e/source/writeCase_a_f32.c | 51 + .../fp/TestFloat-3e/source/writeCase_a_f64.c | 55 + .../fp/TestFloat-3e/source/writeCase_a_ui32.c | 51 + .../fp/TestFloat-3e/source/writeCase_a_ui64.c | 51 + .../source/writeCase_ab_extF80M.c | 62 + .../TestFloat-3e/source/writeCase_ab_f128M.c | 57 + .../fp/TestFloat-3e/source/writeCase_ab_f16.c | 57 + .../fp/TestFloat-3e/source/writeCase_ab_f32.c | 53 + .../fp/TestFloat-3e/source/writeCase_ab_f64.c | 57 + .../TestFloat-3e/source/writeCase_abc_f128M.c | 61 + .../TestFloat-3e/source/writeCase_abc_f16.c | 59 + .../TestFloat-3e/source/writeCase_abc_f32.c | 55 + .../TestFloat-3e/source/writeCase_abc_f64.c | 59 + .../fp/TestFloat-3e/source/writeCase_z_bool.c | 59 + .../TestFloat-3e/source/writeCase_z_extF80M.c | 67 + .../TestFloat-3e/source/writeCase_z_f128M.c | 67 + .../fp/TestFloat-3e/source/writeCase_z_f16.c | 67 + .../fp/TestFloat-3e/source/writeCase_z_f32.c | 63 + .../fp/TestFloat-3e/source/writeCase_z_f64.c | 67 + .../fp/TestFloat-3e/source/writeCase_z_ui32.c | 62 + .../fp/TestFloat-3e/source/writeCase_z_ui64.c | 62 + .../fp/TestFloat-3e/source/writeHex.c | 224 + .../fp/TestFloat-3e/source/writeHex.h | 61 + 655 files changed, 101460 insertions(+) create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/COPYING.txt create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/README.html create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/README.txt create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/Makefile create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/platform.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-history.html create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-source.html create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat.html create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/extF80M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/f128M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/softfloat_raiseFlags.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/specialize.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/extF80M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/f128M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f16UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f32UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f64UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/softfloat_raiseFlags.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/specialize.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/extF80M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/f128M_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/specialize.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_add.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_div.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq_signaling.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_mul.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_rem.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_roundToInt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sqrt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sub.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_add.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_div.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq_signaling.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_mul.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_rem.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_roundToInt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sqrt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sub.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_add.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_div.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq_signaling.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mul.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mulAdd.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_rem.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_roundToInt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_sqrt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_sub.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_add.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_div.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq_signaling.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mul.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mulAdd.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_rem.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_roundToInt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sqrt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sub.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_add.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_div.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq_signaling.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mul.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mulAdd.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_rem.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_roundToInt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sqrt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sub.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_add.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_div.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq_signaling.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mul.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mulAdd.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_rem.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_roundToInt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sqrt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sub.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_add.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_div.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq_signaling.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_isSignalingNaN.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt_quiet.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mul.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mulAdd.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_rem.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_roundToInt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sqrt.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sub.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui32_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui64_r_minMag.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/include/internals.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/include/opts-GCC.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitiveTypes.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitives.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat_types.h create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add256M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addCarryM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addComplCarryM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsExtF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip32_1.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt32_1.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt_1Ks.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip_1Ks.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare96M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compareNonnormExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros8.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_eq128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_isNaNF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_le128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_lt128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128By32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128MTo256M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128To256M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64ByShifted32To128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_negXM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normExtF80SigM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackMToExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackMToF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToExtF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalExtF80Sig.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF128Sig.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF128SigM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF16Sig.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF32Sig.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF64Sig.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_remStepMBy32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundMToI64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundMToUI64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToExtF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftLeftM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftNormSigF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam128Extra.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam256M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64Extra.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJamM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeft128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeft64To96M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeftM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRight128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightExtendM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128Extra.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam64Extra.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJamM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub1XM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub256M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subM.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsExtF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_tryPropagateNaNExtF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/s_tryPropagateNaNF128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/softfloat_state.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f64.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_extF80.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_extF80M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128M.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f16.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f32.c create mode 100644 wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/COPYING.txt create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/README.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/README.txt create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/template/Makefile create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/build/template/platform.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-general.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-history.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-source.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_gen.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_ver.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/testsoftfloat.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/doc/timesoftfloat.html create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/fail.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/fail.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/functionInfos.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/functions.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/functions_common.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_common.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_writeTestsTotal.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/random.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/random.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/standardFunctionInfos.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat_config.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat_functions.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops_common.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_x.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_extF80_z_bool.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f128_z_bool.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f16_z_bool.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f32_z_bool.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f64_z_bool.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64_rx.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/testfloat.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/testfloat_gen.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/testfloat_ver.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/testsoftfloat.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/timesoftfloat.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/uint128.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/uint128.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/uint128_inline.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/verCases.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/verCases_common.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/verCases_inline.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/verCases_writeFunctionName.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/verLoops.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/verLoops.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase.h create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_a_extF80M.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_a_f128M.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_a_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_a_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_a_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_a_ui32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_a_ui64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_ab_extF80M.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_ab_f128M.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_ab_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_ab_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_ab_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_abc_f128M.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_abc_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_abc_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_abc_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_bool.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_extF80M.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_f128M.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_f16.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_f32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_f64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_ui32.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeCase_z_ui64.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeHex.c create mode 100644 wally-pipelined/testbench/fp/TestFloat-3e/source/writeHex.h diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/COPYING.txt b/wally-pipelined/testbench/fp/SoftFloat-3e/COPYING.txt new file mode 100644 index 000000000..9c05d49ca --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/COPYING.txt @@ -0,0 +1,37 @@ + +License for Berkeley SoftFloat Release 3e + +John R. Hauser +2018 January 20 + +The following applies to the whole of SoftFloat Release 3e as well as to +each source file individually. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions, and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/README.html b/wally-pipelined/testbench/fp/SoftFloat-3e/README.html new file mode 100644 index 000000000..7989e0c26 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/README.html @@ -0,0 +1,49 @@ + + + + +Berkeley SoftFloat Package Overview + + + + +

Package Overview for Berkeley SoftFloat Release 3e

+ +

+John R. Hauser
+2018 January 20
+

+ +

+Berkeley SoftFloat is a software implementation of binary floating-point that +conforms to the IEEE Standard for Floating-Point Arithmetic. +SoftFloat is distributed in the form of C source code. +Building the SoftFloat sources generates a library file (typically +softfloat.a or libsoftfloat.a) containing the +floating-point subroutines. +

+ +

+The SoftFloat package is documented in the following files in the +doc subdirectory: +

+ + + + + + + + + + + + + +
SoftFloat.htmlDocumentation for using the SoftFloat functions.
SoftFloat-source.htmlDocumentation for building SoftFloat.
SoftFloat-history.html   History of the major changes to SoftFloat.
+
+Other files in the package comprise the source code for SoftFloat. +

+ + + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/README.txt b/wally-pipelined/testbench/fp/SoftFloat-3e/README.txt new file mode 100644 index 000000000..f819baa5c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/README.txt @@ -0,0 +1,21 @@ + +Package Overview for Berkeley SoftFloat Release 3e + +John R. Hauser +2018 January 20 + +Berkeley SoftFloat is a software implementation of binary floating-point +that conforms to the IEEE Standard for Floating-Point Arithmetic. SoftFloat +is distributed in the form of C source code. Building the SoftFloat sources +generates a library file (typically "softfloat.a" or "libsoftfloat.a") +containing the floating-point subroutines. + +The SoftFloat package is documented in the following files in the "doc" +subdirectory: + + SoftFloat.html Documentation for using the SoftFloat functions. + SoftFloat-source.html Documentation for building SoftFloat. + SoftFloat-history.html History of the major changes to SoftFloat. + +Other files in the package comprise the source code for SoftFloat. + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/Makefile new file mode 100644 index 000000000..418160051 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/Makefile @@ -0,0 +1,325 @@ + +#============================================================================= +# +# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic +# Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SPECIALIZE_TYPE ?= 8086 + +SOFTFLOAT_OPTS ?= \ + -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ + -DSOFTFLOAT_FAST_DIV64TO32 + +DELETE = rm -f +C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +MAKELIB = ar crs $@ + +OBJ = .o +LIB = .a + +OTHER_HEADERS = + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_compare96M$(OBJ) \ + s_compare128M$(OBJ) \ + s_shortShiftLeft64To96M$(OBJ) \ + s_shortShiftLeftM$(OBJ) \ + s_shiftLeftM$(OBJ) \ + s_shortShiftRightM$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJamM$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJamM$(OBJ) \ + s_shiftRightM$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_addM$(OBJ) \ + s_addCarryM$(OBJ) \ + s_addComplCarryM$(OBJ) \ + s_negXM$(OBJ) \ + s_sub1XM$(OBJ) \ + s_subM$(OBJ) \ + s_mul64To128M$(OBJ) \ + s_mul128MTo256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + s_remStepMBy32$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80MToCommonNaN$(OBJ) \ + s_commonNaNToExtF80M$(OBJ) \ + s_propagateNaNExtF80M$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128MToCommonNaN$(OBJ) \ + s_commonNaNToF128M$(OBJ) \ + s_propagateNaNF128M$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundMToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundMToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_tryPropagateNaNExtF80M$(OBJ) \ + s_invalidExtF80M$(OBJ) \ + s_normExtF80SigM$(OBJ) \ + s_roundPackMToExtF80M$(OBJ) \ + s_normRoundPackMToExtF80M$(OBJ) \ + s_addExtF80M$(OBJ) \ + s_compareNonnormExtF80M$(OBJ) \ + s_isNaNF128M$(OBJ) \ + s_tryPropagateNaNF128M$(OBJ) \ + s_invalidF128M$(OBJ) \ + s_shiftNormSigF128M$(OBJ) \ + s_roundPackMToF128M$(OBJ) \ + s_normRoundPackMToF128M$(OBJ) \ + s_addF128M$(OBJ) \ + s_mulAddF128M$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/platform.h new file mode 100644 index 000000000..420aa4e04 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-GCC/platform.h @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define SOFTFLOAT_BUILTIN_CLZ 1 +#include "opts-GCC.h" + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/Makefile new file mode 100644 index 000000000..1cf6f5e1a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/Makefile @@ -0,0 +1,325 @@ + +#============================================================================= +# +# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic +# Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SPECIALIZE_TYPE ?= 8086-SSE + +SOFTFLOAT_OPTS ?= \ + -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ + -DSOFTFLOAT_FAST_DIV64TO32 + +DELETE = rm -f +C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +MAKELIB = ar crs $@ + +OBJ = .o +LIB = .a + +OTHER_HEADERS = + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_compare96M$(OBJ) \ + s_compare128M$(OBJ) \ + s_shortShiftLeft64To96M$(OBJ) \ + s_shortShiftLeftM$(OBJ) \ + s_shiftLeftM$(OBJ) \ + s_shortShiftRightM$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJamM$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJamM$(OBJ) \ + s_shiftRightM$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_addM$(OBJ) \ + s_addCarryM$(OBJ) \ + s_addComplCarryM$(OBJ) \ + s_negXM$(OBJ) \ + s_sub1XM$(OBJ) \ + s_subM$(OBJ) \ + s_mul64To128M$(OBJ) \ + s_mul128MTo256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + s_remStepMBy32$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80MToCommonNaN$(OBJ) \ + s_commonNaNToExtF80M$(OBJ) \ + s_propagateNaNExtF80M$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128MToCommonNaN$(OBJ) \ + s_commonNaNToF128M$(OBJ) \ + s_propagateNaNF128M$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundMToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundMToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_tryPropagateNaNExtF80M$(OBJ) \ + s_invalidExtF80M$(OBJ) \ + s_normExtF80SigM$(OBJ) \ + s_roundPackMToExtF80M$(OBJ) \ + s_normRoundPackMToExtF80M$(OBJ) \ + s_addExtF80M$(OBJ) \ + s_compareNonnormExtF80M$(OBJ) \ + s_isNaNF128M$(OBJ) \ + s_tryPropagateNaNF128M$(OBJ) \ + s_invalidF128M$(OBJ) \ + s_shiftNormSigF128M$(OBJ) \ + s_roundPackMToF128M$(OBJ) \ + s_normRoundPackMToF128M$(OBJ) \ + s_addF128M$(OBJ) \ + s_mulAddF128M$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/platform.h new file mode 100644 index 000000000..420aa4e04 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-386-SSE2-GCC/platform.h @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define SOFTFLOAT_BUILTIN_CLZ 1 +#include "opts-GCC.h" + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile new file mode 100644 index 000000000..2565fe56c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile @@ -0,0 +1,323 @@ + +#============================================================================= +# +# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic +# Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SPECIALIZE_TYPE ?= ARM-VFPv2 + +SOFTFLOAT_OPTS ?= -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 + +DELETE = rm -f +C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +MAKELIB = ar crs $@ + +OBJ = .o +LIB = .a + +OTHER_HEADERS = + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_compare96M$(OBJ) \ + s_compare128M$(OBJ) \ + s_shortShiftLeft64To96M$(OBJ) \ + s_shortShiftLeftM$(OBJ) \ + s_shiftLeftM$(OBJ) \ + s_shortShiftRightM$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJamM$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJamM$(OBJ) \ + s_shiftRightM$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_addM$(OBJ) \ + s_addCarryM$(OBJ) \ + s_addComplCarryM$(OBJ) \ + s_negXM$(OBJ) \ + s_sub1XM$(OBJ) \ + s_subM$(OBJ) \ + s_mul64To128M$(OBJ) \ + s_mul128MTo256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + s_remStepMBy32$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80MToCommonNaN$(OBJ) \ + s_commonNaNToExtF80M$(OBJ) \ + s_propagateNaNExtF80M$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128MToCommonNaN$(OBJ) \ + s_commonNaNToF128M$(OBJ) \ + s_propagateNaNF128M$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundMToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundMToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_tryPropagateNaNExtF80M$(OBJ) \ + s_invalidExtF80M$(OBJ) \ + s_normExtF80SigM$(OBJ) \ + s_roundPackMToExtF80M$(OBJ) \ + s_normRoundPackMToExtF80M$(OBJ) \ + s_addExtF80M$(OBJ) \ + s_compareNonnormExtF80M$(OBJ) \ + s_isNaNF128M$(OBJ) \ + s_tryPropagateNaNF128M$(OBJ) \ + s_invalidF128M$(OBJ) \ + s_shiftNormSigF128M$(OBJ) \ + s_roundPackMToF128M$(OBJ) \ + s_normRoundPackMToF128M$(OBJ) \ + s_addF128M$(OBJ) \ + s_mulAddF128M$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h new file mode 100644 index 000000000..420aa4e04 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define SOFTFLOAT_BUILTIN_CLZ 1 +#include "opts-GCC.h" + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/Makefile new file mode 100644 index 000000000..570337825 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/Makefile @@ -0,0 +1,390 @@ + +#============================================================================= +# +# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic +# Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SPECIALIZE_TYPE ?= 8086-SSE + +SOFTFLOAT_OPTS ?= \ + -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ + -DSOFTFLOAT_FAST_DIV64TO32 + +DELETE = rm -f +C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \ + $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +MAKELIB = ar crs $@ + +OBJ = .o +LIB = .a + +OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_eq128$(OBJ) \ + s_le128$(OBJ) \ + s_lt128$(OBJ) \ + s_shortShiftLeft128$(OBJ) \ + s_shortShiftRight128$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJam64Extra$(OBJ) \ + s_shortShiftRightJam128$(OBJ) \ + s_shortShiftRightJam128Extra$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJam64Extra$(OBJ) \ + s_shiftRightJam128$(OBJ) \ + s_shiftRightJam128Extra$(OBJ) \ + s_shiftRightJam256M$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_add128$(OBJ) \ + s_add256M$(OBJ) \ + s_sub128$(OBJ) \ + s_sub256M$(OBJ) \ + s_mul64ByShifted32To128$(OBJ) \ + s_mul64To128$(OBJ) \ + s_mul128By32$(OBJ) \ + s_mul128To256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80UIToCommonNaN$(OBJ) \ + s_commonNaNToExtF80UI$(OBJ) \ + s_propagateNaNExtF80UI$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128UIToCommonNaN$(OBJ) \ + s_commonNaNToF128UI$(OBJ) \ + s_propagateNaNF128UI$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_normSubnormalExtF80Sig$(OBJ) \ + s_roundPackToExtF80$(OBJ) \ + s_normRoundPackToExtF80$(OBJ) \ + s_addMagsExtF80$(OBJ) \ + s_subMagsExtF80$(OBJ) \ + s_normSubnormalF128Sig$(OBJ) \ + s_roundPackToF128$(OBJ) \ + s_normRoundPackToF128$(OBJ) \ + s_addMagsF128$(OBJ) \ + s_subMagsF128$(OBJ) \ + s_mulAddF128$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80_to_ui32$(OBJ) \ + extF80_to_ui64$(OBJ) \ + extF80_to_i32$(OBJ) \ + extF80_to_i64$(OBJ) \ + extF80_to_ui32_r_minMag$(OBJ) \ + extF80_to_ui64_r_minMag$(OBJ) \ + extF80_to_i32_r_minMag$(OBJ) \ + extF80_to_i64_r_minMag$(OBJ) \ + extF80_to_f16$(OBJ) \ + extF80_to_f32$(OBJ) \ + extF80_to_f64$(OBJ) \ + extF80_to_f128$(OBJ) \ + extF80_roundToInt$(OBJ) \ + extF80_add$(OBJ) \ + extF80_sub$(OBJ) \ + extF80_mul$(OBJ) \ + extF80_div$(OBJ) \ + extF80_rem$(OBJ) \ + extF80_sqrt$(OBJ) \ + extF80_eq$(OBJ) \ + extF80_le$(OBJ) \ + extF80_lt$(OBJ) \ + extF80_eq_signaling$(OBJ) \ + extF80_le_quiet$(OBJ) \ + extF80_lt_quiet$(OBJ) \ + extF80_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128_to_ui32$(OBJ) \ + f128_to_ui64$(OBJ) \ + f128_to_i32$(OBJ) \ + f128_to_i64$(OBJ) \ + f128_to_ui32_r_minMag$(OBJ) \ + f128_to_ui64_r_minMag$(OBJ) \ + f128_to_i32_r_minMag$(OBJ) \ + f128_to_i64_r_minMag$(OBJ) \ + f128_to_f16$(OBJ) \ + f128_to_f32$(OBJ) \ + f128_to_extF80$(OBJ) \ + f128_to_f64$(OBJ) \ + f128_roundToInt$(OBJ) \ + f128_add$(OBJ) \ + f128_sub$(OBJ) \ + f128_mul$(OBJ) \ + f128_mulAdd$(OBJ) \ + f128_div$(OBJ) \ + f128_rem$(OBJ) \ + f128_sqrt$(OBJ) \ + f128_eq$(OBJ) \ + f128_le$(OBJ) \ + f128_lt$(OBJ) \ + f128_eq_signaling$(OBJ) \ + f128_le_quiet$(OBJ) \ + f128_lt_quiet$(OBJ) \ + f128_isSignalingNaN$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/platform.h new file mode 100644 index 000000000..2fccb6c09 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Linux-x86_64-GCC/platform.h @@ -0,0 +1,54 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define SOFTFLOAT_BUILTIN_CLZ 1 +#define SOFTFLOAT_INTRINSIC_INT128 1 +#include "opts-GCC.h" + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/Makefile new file mode 100644 index 000000000..418160051 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/Makefile @@ -0,0 +1,325 @@ + +#============================================================================= +# +# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic +# Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SPECIALIZE_TYPE ?= 8086 + +SOFTFLOAT_OPTS ?= \ + -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ + -DSOFTFLOAT_FAST_DIV64TO32 + +DELETE = rm -f +C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +MAKELIB = ar crs $@ + +OBJ = .o +LIB = .a + +OTHER_HEADERS = + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_compare96M$(OBJ) \ + s_compare128M$(OBJ) \ + s_shortShiftLeft64To96M$(OBJ) \ + s_shortShiftLeftM$(OBJ) \ + s_shiftLeftM$(OBJ) \ + s_shortShiftRightM$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJamM$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJamM$(OBJ) \ + s_shiftRightM$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_addM$(OBJ) \ + s_addCarryM$(OBJ) \ + s_addComplCarryM$(OBJ) \ + s_negXM$(OBJ) \ + s_sub1XM$(OBJ) \ + s_subM$(OBJ) \ + s_mul64To128M$(OBJ) \ + s_mul128MTo256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + s_remStepMBy32$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80MToCommonNaN$(OBJ) \ + s_commonNaNToExtF80M$(OBJ) \ + s_propagateNaNExtF80M$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128MToCommonNaN$(OBJ) \ + s_commonNaNToF128M$(OBJ) \ + s_propagateNaNF128M$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundMToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundMToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_tryPropagateNaNExtF80M$(OBJ) \ + s_invalidExtF80M$(OBJ) \ + s_normExtF80SigM$(OBJ) \ + s_roundPackMToExtF80M$(OBJ) \ + s_normRoundPackMToExtF80M$(OBJ) \ + s_addExtF80M$(OBJ) \ + s_compareNonnormExtF80M$(OBJ) \ + s_isNaNF128M$(OBJ) \ + s_tryPropagateNaNF128M$(OBJ) \ + s_invalidF128M$(OBJ) \ + s_shiftNormSigF128M$(OBJ) \ + s_roundPackMToF128M$(OBJ) \ + s_normRoundPackMToF128M$(OBJ) \ + s_addF128M$(OBJ) \ + s_mulAddF128M$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/platform.h new file mode 100644 index 000000000..420aa4e04 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-MinGW/platform.h @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define SOFTFLOAT_BUILTIN_CLZ 1 +#include "opts-GCC.h" + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/Makefile new file mode 100644 index 000000000..1cf6f5e1a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/Makefile @@ -0,0 +1,325 @@ + +#============================================================================= +# +# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic +# Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SPECIALIZE_TYPE ?= 8086-SSE + +SOFTFLOAT_OPTS ?= \ + -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ + -DSOFTFLOAT_FAST_DIV64TO32 + +DELETE = rm -f +C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +MAKELIB = ar crs $@ + +OBJ = .o +LIB = .a + +OTHER_HEADERS = + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_compare96M$(OBJ) \ + s_compare128M$(OBJ) \ + s_shortShiftLeft64To96M$(OBJ) \ + s_shortShiftLeftM$(OBJ) \ + s_shiftLeftM$(OBJ) \ + s_shortShiftRightM$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJamM$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJamM$(OBJ) \ + s_shiftRightM$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_addM$(OBJ) \ + s_addCarryM$(OBJ) \ + s_addComplCarryM$(OBJ) \ + s_negXM$(OBJ) \ + s_sub1XM$(OBJ) \ + s_subM$(OBJ) \ + s_mul64To128M$(OBJ) \ + s_mul128MTo256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + s_remStepMBy32$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80MToCommonNaN$(OBJ) \ + s_commonNaNToExtF80M$(OBJ) \ + s_propagateNaNExtF80M$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128MToCommonNaN$(OBJ) \ + s_commonNaNToF128M$(OBJ) \ + s_propagateNaNF128M$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundMToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundMToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_tryPropagateNaNExtF80M$(OBJ) \ + s_invalidExtF80M$(OBJ) \ + s_normExtF80SigM$(OBJ) \ + s_roundPackMToExtF80M$(OBJ) \ + s_normRoundPackMToExtF80M$(OBJ) \ + s_addExtF80M$(OBJ) \ + s_compareNonnormExtF80M$(OBJ) \ + s_isNaNF128M$(OBJ) \ + s_tryPropagateNaNF128M$(OBJ) \ + s_invalidF128M$(OBJ) \ + s_shiftNormSigF128M$(OBJ) \ + s_roundPackMToF128M$(OBJ) \ + s_normRoundPackMToF128M$(OBJ) \ + s_addF128M$(OBJ) \ + s_mulAddF128M$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/platform.h new file mode 100644 index 000000000..420aa4e04 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win32-SSE2-MinGW/platform.h @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define SOFTFLOAT_BUILTIN_CLZ 1 +#include "opts-GCC.h" + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/Makefile new file mode 100644 index 000000000..05bbf5bb5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/Makefile @@ -0,0 +1,390 @@ + +#============================================================================= +# +# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic +# Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SPECIALIZE_TYPE ?= 8086-SSE + +SOFTFLOAT_OPTS ?= \ + -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ + -DSOFTFLOAT_FAST_DIV64TO32 + +DELETE = rm -f +C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +COMPILE_C = \ + x86_64-w64-mingw32-gcc -c -Werror-implicit-function-declaration \ + -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +MAKELIB = x86_64-w64-mingw32-ar crs $@ + +OBJ = .o +LIB = .a + +OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_eq128$(OBJ) \ + s_le128$(OBJ) \ + s_lt128$(OBJ) \ + s_shortShiftLeft128$(OBJ) \ + s_shortShiftRight128$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJam64Extra$(OBJ) \ + s_shortShiftRightJam128$(OBJ) \ + s_shortShiftRightJam128Extra$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJam64Extra$(OBJ) \ + s_shiftRightJam128$(OBJ) \ + s_shiftRightJam128Extra$(OBJ) \ + s_shiftRightJam256M$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_add128$(OBJ) \ + s_add256M$(OBJ) \ + s_sub128$(OBJ) \ + s_sub256M$(OBJ) \ + s_mul64ByShifted32To128$(OBJ) \ + s_mul64To128$(OBJ) \ + s_mul128By32$(OBJ) \ + s_mul128To256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80UIToCommonNaN$(OBJ) \ + s_commonNaNToExtF80UI$(OBJ) \ + s_propagateNaNExtF80UI$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128UIToCommonNaN$(OBJ) \ + s_commonNaNToF128UI$(OBJ) \ + s_propagateNaNF128UI$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_normSubnormalExtF80Sig$(OBJ) \ + s_roundPackToExtF80$(OBJ) \ + s_normRoundPackToExtF80$(OBJ) \ + s_addMagsExtF80$(OBJ) \ + s_subMagsExtF80$(OBJ) \ + s_normSubnormalF128Sig$(OBJ) \ + s_roundPackToF128$(OBJ) \ + s_normRoundPackToF128$(OBJ) \ + s_addMagsF128$(OBJ) \ + s_subMagsF128$(OBJ) \ + s_mulAddF128$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80_to_ui32$(OBJ) \ + extF80_to_ui64$(OBJ) \ + extF80_to_i32$(OBJ) \ + extF80_to_i64$(OBJ) \ + extF80_to_ui32_r_minMag$(OBJ) \ + extF80_to_ui64_r_minMag$(OBJ) \ + extF80_to_i32_r_minMag$(OBJ) \ + extF80_to_i64_r_minMag$(OBJ) \ + extF80_to_f16$(OBJ) \ + extF80_to_f32$(OBJ) \ + extF80_to_f64$(OBJ) \ + extF80_to_f128$(OBJ) \ + extF80_roundToInt$(OBJ) \ + extF80_add$(OBJ) \ + extF80_sub$(OBJ) \ + extF80_mul$(OBJ) \ + extF80_div$(OBJ) \ + extF80_rem$(OBJ) \ + extF80_sqrt$(OBJ) \ + extF80_eq$(OBJ) \ + extF80_le$(OBJ) \ + extF80_lt$(OBJ) \ + extF80_eq_signaling$(OBJ) \ + extF80_le_quiet$(OBJ) \ + extF80_lt_quiet$(OBJ) \ + extF80_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128_to_ui32$(OBJ) \ + f128_to_ui64$(OBJ) \ + f128_to_i32$(OBJ) \ + f128_to_i64$(OBJ) \ + f128_to_ui32_r_minMag$(OBJ) \ + f128_to_ui64_r_minMag$(OBJ) \ + f128_to_i32_r_minMag$(OBJ) \ + f128_to_i64_r_minMag$(OBJ) \ + f128_to_f16$(OBJ) \ + f128_to_f32$(OBJ) \ + f128_to_extF80$(OBJ) \ + f128_to_f64$(OBJ) \ + f128_roundToInt$(OBJ) \ + f128_add$(OBJ) \ + f128_sub$(OBJ) \ + f128_mul$(OBJ) \ + f128_mulAdd$(OBJ) \ + f128_div$(OBJ) \ + f128_rem$(OBJ) \ + f128_sqrt$(OBJ) \ + f128_eq$(OBJ) \ + f128_le$(OBJ) \ + f128_lt$(OBJ) \ + f128_eq_signaling$(OBJ) \ + f128_le_quiet$(OBJ) \ + f128_lt_quiet$(OBJ) \ + f128_isSignalingNaN$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/platform.h new file mode 100644 index 000000000..2fccb6c09 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/Win64-MinGW-w64/platform.h @@ -0,0 +1,54 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define SOFTFLOAT_BUILTIN_CLZ 1 +#define SOFTFLOAT_INTRINSIC_INT128 1 +#include "opts-GCC.h" + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/Makefile new file mode 100644 index 000000000..c5005e6e3 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/Makefile @@ -0,0 +1,391 @@ + +#============================================================================= +# +# This Makefile template is part of the SoftFloat IEEE Floating-Point +# Arithmetic Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +# Edit lines marked with `==>'. See "SoftFloat-source.html". + +==> SOURCE_DIR ?= ../../source +==> SPECIALIZE_TYPE ?= 8086 + +==> SOFTFLOAT_OPTS ?= \ +==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ +==> -DSOFTFLOAT_FAST_DIV64TO32 + +==> DELETE = rm -f +==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +==> COMPILE_C = \ +==> cc -c -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +==> MAKELIB = ar crs $@ + +==> OBJ = .o +==> LIB = .a + +==> OTHER_HEADERS = + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_eq128$(OBJ) \ + s_le128$(OBJ) \ + s_lt128$(OBJ) \ + s_shortShiftLeft128$(OBJ) \ + s_shortShiftRight128$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJam64Extra$(OBJ) \ + s_shortShiftRightJam128$(OBJ) \ + s_shortShiftRightJam128Extra$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJam64Extra$(OBJ) \ + s_shiftRightJam128$(OBJ) \ + s_shiftRightJam128Extra$(OBJ) \ + s_shiftRightJam256M$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_add128$(OBJ) \ + s_add256M$(OBJ) \ + s_sub128$(OBJ) \ + s_sub256M$(OBJ) \ + s_mul64ByShifted32To128$(OBJ) \ + s_mul64To128$(OBJ) \ + s_mul128By32$(OBJ) \ + s_mul128To256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80UIToCommonNaN$(OBJ) \ + s_commonNaNToExtF80UI$(OBJ) \ + s_propagateNaNExtF80UI$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128UIToCommonNaN$(OBJ) \ + s_commonNaNToF128UI$(OBJ) \ + s_propagateNaNF128UI$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_normSubnormalExtF80Sig$(OBJ) \ + s_roundPackToExtF80$(OBJ) \ + s_normRoundPackToExtF80$(OBJ) \ + s_addMagsExtF80$(OBJ) \ + s_subMagsExtF80$(OBJ) \ + s_normSubnormalF128Sig$(OBJ) \ + s_roundPackToF128$(OBJ) \ + s_normRoundPackToF128$(OBJ) \ + s_addMagsF128$(OBJ) \ + s_subMagsF128$(OBJ) \ + s_mulAddF128$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80_to_ui32$(OBJ) \ + extF80_to_ui64$(OBJ) \ + extF80_to_i32$(OBJ) \ + extF80_to_i64$(OBJ) \ + extF80_to_ui32_r_minMag$(OBJ) \ + extF80_to_ui64_r_minMag$(OBJ) \ + extF80_to_i32_r_minMag$(OBJ) \ + extF80_to_i64_r_minMag$(OBJ) \ + extF80_to_f16$(OBJ) \ + extF80_to_f32$(OBJ) \ + extF80_to_f64$(OBJ) \ + extF80_to_f128$(OBJ) \ + extF80_roundToInt$(OBJ) \ + extF80_add$(OBJ) \ + extF80_sub$(OBJ) \ + extF80_mul$(OBJ) \ + extF80_div$(OBJ) \ + extF80_rem$(OBJ) \ + extF80_sqrt$(OBJ) \ + extF80_eq$(OBJ) \ + extF80_le$(OBJ) \ + extF80_lt$(OBJ) \ + extF80_eq_signaling$(OBJ) \ + extF80_le_quiet$(OBJ) \ + extF80_lt_quiet$(OBJ) \ + extF80_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128_to_ui32$(OBJ) \ + f128_to_ui64$(OBJ) \ + f128_to_i32$(OBJ) \ + f128_to_i64$(OBJ) \ + f128_to_ui32_r_minMag$(OBJ) \ + f128_to_ui64_r_minMag$(OBJ) \ + f128_to_i32_r_minMag$(OBJ) \ + f128_to_i64_r_minMag$(OBJ) \ + f128_to_f16$(OBJ) \ + f128_to_f32$(OBJ) \ + f128_to_extF80$(OBJ) \ + f128_to_f64$(OBJ) \ + f128_roundToInt$(OBJ) \ + f128_add$(OBJ) \ + f128_sub$(OBJ) \ + f128_mul$(OBJ) \ + f128_mulAdd$(OBJ) \ + f128_div$(OBJ) \ + f128_rem$(OBJ) \ + f128_sqrt$(OBJ) \ + f128_eq$(OBJ) \ + f128_le$(OBJ) \ + f128_lt$(OBJ) \ + f128_eq_signaling$(OBJ) \ + f128_le_quiet$(OBJ) \ + f128_lt_quiet$(OBJ) \ + f128_isSignalingNaN$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/platform.h new file mode 100644 index 000000000..b63e2a720 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-FAST_INT64/platform.h @@ -0,0 +1,50 @@ + +/*============================================================================ + +This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +// Edit lines marked with `==>'. See "SoftFloat-source.html". + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define INLINE inline + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define THREAD_LOCAL _Thread_local + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/Makefile b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/Makefile new file mode 100644 index 000000000..49fddfd02 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/Makefile @@ -0,0 +1,325 @@ + +#============================================================================= +# +# This Makefile template is part of the SoftFloat IEEE Floating-Point +# Arithmetic Package, Release 3e, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +# Edit lines marked with `==>'. See "SoftFloat-source.html". + +==> SOURCE_DIR ?= ../../source +==> SPECIALIZE_TYPE ?= 8086 + +==> SOFTFLOAT_OPTS ?= \ +==> -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \ +==> -DSOFTFLOAT_FAST_DIV64TO32 + +==> DELETE = rm -f +==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include +==> COMPILE_C = cc -c $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +==> MAKELIB = ar crs $@ + +==> OBJ = .o +==> LIB = .a + +==> OTHER_HEADERS = + +.PHONY: all +all: softfloat$(LIB) + +OBJS_PRIMITIVES = \ + s_compare96M$(OBJ) \ + s_compare128M$(OBJ) \ + s_shortShiftLeft64To96M$(OBJ) \ + s_shortShiftLeftM$(OBJ) \ + s_shiftLeftM$(OBJ) \ + s_shortShiftRightM$(OBJ) \ + s_shortShiftRightJam64$(OBJ) \ + s_shortShiftRightJamM$(OBJ) \ + s_shiftRightJam32$(OBJ) \ + s_shiftRightJam64$(OBJ) \ + s_shiftRightJamM$(OBJ) \ + s_shiftRightM$(OBJ) \ + s_countLeadingZeros8$(OBJ) \ + s_countLeadingZeros16$(OBJ) \ + s_countLeadingZeros32$(OBJ) \ + s_countLeadingZeros64$(OBJ) \ + s_addM$(OBJ) \ + s_addCarryM$(OBJ) \ + s_addComplCarryM$(OBJ) \ + s_negXM$(OBJ) \ + s_sub1XM$(OBJ) \ + s_subM$(OBJ) \ + s_mul64To128M$(OBJ) \ + s_mul128MTo256M$(OBJ) \ + s_approxRecip_1Ks$(OBJ) \ + s_approxRecip32_1$(OBJ) \ + s_approxRecipSqrt_1Ks$(OBJ) \ + s_approxRecipSqrt32_1$(OBJ) \ + s_remStepMBy32$(OBJ) \ + +OBJS_SPECIALIZE = \ + softfloat_raiseFlags$(OBJ) \ + s_f16UIToCommonNaN$(OBJ) \ + s_commonNaNToF16UI$(OBJ) \ + s_propagateNaNF16UI$(OBJ) \ + s_f32UIToCommonNaN$(OBJ) \ + s_commonNaNToF32UI$(OBJ) \ + s_propagateNaNF32UI$(OBJ) \ + s_f64UIToCommonNaN$(OBJ) \ + s_commonNaNToF64UI$(OBJ) \ + s_propagateNaNF64UI$(OBJ) \ + extF80M_isSignalingNaN$(OBJ) \ + s_extF80MToCommonNaN$(OBJ) \ + s_commonNaNToExtF80M$(OBJ) \ + s_propagateNaNExtF80M$(OBJ) \ + f128M_isSignalingNaN$(OBJ) \ + s_f128MToCommonNaN$(OBJ) \ + s_commonNaNToF128M$(OBJ) \ + s_propagateNaNF128M$(OBJ) \ + +OBJS_OTHERS = \ + s_roundToUI32$(OBJ) \ + s_roundMToUI64$(OBJ) \ + s_roundToI32$(OBJ) \ + s_roundMToI64$(OBJ) \ + s_normSubnormalF16Sig$(OBJ) \ + s_roundPackToF16$(OBJ) \ + s_normRoundPackToF16$(OBJ) \ + s_addMagsF16$(OBJ) \ + s_subMagsF16$(OBJ) \ + s_mulAddF16$(OBJ) \ + s_normSubnormalF32Sig$(OBJ) \ + s_roundPackToF32$(OBJ) \ + s_normRoundPackToF32$(OBJ) \ + s_addMagsF32$(OBJ) \ + s_subMagsF32$(OBJ) \ + s_mulAddF32$(OBJ) \ + s_normSubnormalF64Sig$(OBJ) \ + s_roundPackToF64$(OBJ) \ + s_normRoundPackToF64$(OBJ) \ + s_addMagsF64$(OBJ) \ + s_subMagsF64$(OBJ) \ + s_mulAddF64$(OBJ) \ + s_tryPropagateNaNExtF80M$(OBJ) \ + s_invalidExtF80M$(OBJ) \ + s_normExtF80SigM$(OBJ) \ + s_roundPackMToExtF80M$(OBJ) \ + s_normRoundPackMToExtF80M$(OBJ) \ + s_addExtF80M$(OBJ) \ + s_compareNonnormExtF80M$(OBJ) \ + s_isNaNF128M$(OBJ) \ + s_tryPropagateNaNF128M$(OBJ) \ + s_invalidF128M$(OBJ) \ + s_shiftNormSigF128M$(OBJ) \ + s_roundPackMToF128M$(OBJ) \ + s_normRoundPackMToF128M$(OBJ) \ + s_addF128M$(OBJ) \ + s_mulAddF128M$(OBJ) \ + softfloat_state$(OBJ) \ + ui32_to_f16$(OBJ) \ + ui32_to_f32$(OBJ) \ + ui32_to_f64$(OBJ) \ + ui32_to_extF80M$(OBJ) \ + ui32_to_f128M$(OBJ) \ + ui64_to_f16$(OBJ) \ + ui64_to_f32$(OBJ) \ + ui64_to_f64$(OBJ) \ + ui64_to_extF80M$(OBJ) \ + ui64_to_f128M$(OBJ) \ + i32_to_f16$(OBJ) \ + i32_to_f32$(OBJ) \ + i32_to_f64$(OBJ) \ + i32_to_extF80M$(OBJ) \ + i32_to_f128M$(OBJ) \ + i64_to_f16$(OBJ) \ + i64_to_f32$(OBJ) \ + i64_to_f64$(OBJ) \ + i64_to_extF80M$(OBJ) \ + i64_to_f128M$(OBJ) \ + f16_to_ui32$(OBJ) \ + f16_to_ui64$(OBJ) \ + f16_to_i32$(OBJ) \ + f16_to_i64$(OBJ) \ + f16_to_ui32_r_minMag$(OBJ) \ + f16_to_ui64_r_minMag$(OBJ) \ + f16_to_i32_r_minMag$(OBJ) \ + f16_to_i64_r_minMag$(OBJ) \ + f16_to_f32$(OBJ) \ + f16_to_f64$(OBJ) \ + f16_to_extF80M$(OBJ) \ + f16_to_f128M$(OBJ) \ + f16_roundToInt$(OBJ) \ + f16_add$(OBJ) \ + f16_sub$(OBJ) \ + f16_mul$(OBJ) \ + f16_mulAdd$(OBJ) \ + f16_div$(OBJ) \ + f16_rem$(OBJ) \ + f16_sqrt$(OBJ) \ + f16_eq$(OBJ) \ + f16_le$(OBJ) \ + f16_lt$(OBJ) \ + f16_eq_signaling$(OBJ) \ + f16_le_quiet$(OBJ) \ + f16_lt_quiet$(OBJ) \ + f16_isSignalingNaN$(OBJ) \ + f32_to_ui32$(OBJ) \ + f32_to_ui64$(OBJ) \ + f32_to_i32$(OBJ) \ + f32_to_i64$(OBJ) \ + f32_to_ui32_r_minMag$(OBJ) \ + f32_to_ui64_r_minMag$(OBJ) \ + f32_to_i32_r_minMag$(OBJ) \ + f32_to_i64_r_minMag$(OBJ) \ + f32_to_f16$(OBJ) \ + f32_to_f64$(OBJ) \ + f32_to_extF80M$(OBJ) \ + f32_to_f128M$(OBJ) \ + f32_roundToInt$(OBJ) \ + f32_add$(OBJ) \ + f32_sub$(OBJ) \ + f32_mul$(OBJ) \ + f32_mulAdd$(OBJ) \ + f32_div$(OBJ) \ + f32_rem$(OBJ) \ + f32_sqrt$(OBJ) \ + f32_eq$(OBJ) \ + f32_le$(OBJ) \ + f32_lt$(OBJ) \ + f32_eq_signaling$(OBJ) \ + f32_le_quiet$(OBJ) \ + f32_lt_quiet$(OBJ) \ + f32_isSignalingNaN$(OBJ) \ + f64_to_ui32$(OBJ) \ + f64_to_ui64$(OBJ) \ + f64_to_i32$(OBJ) \ + f64_to_i64$(OBJ) \ + f64_to_ui32_r_minMag$(OBJ) \ + f64_to_ui64_r_minMag$(OBJ) \ + f64_to_i32_r_minMag$(OBJ) \ + f64_to_i64_r_minMag$(OBJ) \ + f64_to_f16$(OBJ) \ + f64_to_f32$(OBJ) \ + f64_to_extF80M$(OBJ) \ + f64_to_f128M$(OBJ) \ + f64_roundToInt$(OBJ) \ + f64_add$(OBJ) \ + f64_sub$(OBJ) \ + f64_mul$(OBJ) \ + f64_mulAdd$(OBJ) \ + f64_div$(OBJ) \ + f64_rem$(OBJ) \ + f64_sqrt$(OBJ) \ + f64_eq$(OBJ) \ + f64_le$(OBJ) \ + f64_lt$(OBJ) \ + f64_eq_signaling$(OBJ) \ + f64_le_quiet$(OBJ) \ + f64_lt_quiet$(OBJ) \ + f64_isSignalingNaN$(OBJ) \ + extF80M_to_ui32$(OBJ) \ + extF80M_to_ui64$(OBJ) \ + extF80M_to_i32$(OBJ) \ + extF80M_to_i64$(OBJ) \ + extF80M_to_ui32_r_minMag$(OBJ) \ + extF80M_to_ui64_r_minMag$(OBJ) \ + extF80M_to_i32_r_minMag$(OBJ) \ + extF80M_to_i64_r_minMag$(OBJ) \ + extF80M_to_f16$(OBJ) \ + extF80M_to_f32$(OBJ) \ + extF80M_to_f64$(OBJ) \ + extF80M_to_f128M$(OBJ) \ + extF80M_roundToInt$(OBJ) \ + extF80M_add$(OBJ) \ + extF80M_sub$(OBJ) \ + extF80M_mul$(OBJ) \ + extF80M_div$(OBJ) \ + extF80M_rem$(OBJ) \ + extF80M_sqrt$(OBJ) \ + extF80M_eq$(OBJ) \ + extF80M_le$(OBJ) \ + extF80M_lt$(OBJ) \ + extF80M_eq_signaling$(OBJ) \ + extF80M_le_quiet$(OBJ) \ + extF80M_lt_quiet$(OBJ) \ + f128M_to_ui32$(OBJ) \ + f128M_to_ui64$(OBJ) \ + f128M_to_i32$(OBJ) \ + f128M_to_i64$(OBJ) \ + f128M_to_ui32_r_minMag$(OBJ) \ + f128M_to_ui64_r_minMag$(OBJ) \ + f128M_to_i32_r_minMag$(OBJ) \ + f128M_to_i64_r_minMag$(OBJ) \ + f128M_to_f16$(OBJ) \ + f128M_to_f32$(OBJ) \ + f128M_to_f64$(OBJ) \ + f128M_to_extF80M$(OBJ) \ + f128M_roundToInt$(OBJ) \ + f128M_add$(OBJ) \ + f128M_sub$(OBJ) \ + f128M_mul$(OBJ) \ + f128M_mulAdd$(OBJ) \ + f128M_div$(OBJ) \ + f128M_rem$(OBJ) \ + f128M_sqrt$(OBJ) \ + f128M_eq$(OBJ) \ + f128M_le$(OBJ) \ + f128M_lt$(OBJ) \ + f128M_eq_signaling$(OBJ) \ + f128M_le_quiet$(OBJ) \ + f128M_lt_quiet$(OBJ) \ + +OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS) + +$(OBJS_ALL): \ + $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \ + $(SOURCE_DIR)/include/primitives.h +$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \ + $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \ + $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \ + $(SOURCE_DIR)/include/softfloat.h + +$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c + +$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c + +softfloat$(LIB): $(OBJS_ALL) + $(DELETE) $@ + $(MAKELIB) $^ + +.PHONY: clean +clean: + $(DELETE) $(OBJS_ALL) softfloat$(LIB) + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/platform.h b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/platform.h new file mode 100644 index 000000000..b63e2a720 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/build/template-not-FAST_INT64/platform.h @@ -0,0 +1,50 @@ + +/*============================================================================ + +This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +// Edit lines marked with `==>'. See "SoftFloat-source.html". + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define INLINE inline + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define THREAD_LOCAL _Thread_local + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-history.html b/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-history.html new file mode 100644 index 000000000..daa48ca3b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-history.html @@ -0,0 +1,258 @@ + + + + +Berkeley SoftFloat History + + + + +

History of Berkeley SoftFloat, to Release 3e

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Release 3e (2018 January)

+ +
    + +
  • +Changed the default numeric code for optional rounding mode odd +(round to odd, also known as jamming) from 5 to 6. + +
  • +Modified the behavior of rounding mode odd when rounding to an +integer value (either conversion to an integer format or a +‘roundToInt’ function). +Previously, for those cases only, rounding mode odd acted the same +as rounding to minimum magnitude. +Now all operations are rounded consistently. + +
  • +Fixed some errors in the specialization code modeling Intel x86 floating-point, +specifically the integers returned on invalid operations and the propagation of +NaN payloads in a few rare cases. + +
  • +Added specialization code modeling ARM floating-point, conforming to VFPv2 or +later. + +
  • +Added an example target for ARM processors. + +
  • +Fixed a minor bug whereby function f16_to_ui64 might return a +different integer than expected in the case that the floating-point operand is +negative. + +
  • +Added example target-specific optimization for GCC, employing GCC instrinsics +and support for 128-bit integer arithmetic. + +
  • +Made other minor improvements. + +
+ + +

Release 3d (2017 August)

+ +
    + +
  • +Fixed bugs in the square root functions for 64-bit +double-precision, 80-bit double-extended-precision, and +128-bit quadruple-precision. +For 64-bit double-precision (f64_sqrt), the result +could sometimes be off by 1 unit in the last place +(1 ulp) from what it should be. +For the larger formats, the square root could be wrong in a large portion of +the less-significant bits. +(A bug in f128_sqrt was first reported by Alexei Sibidanov.) + +
+ + +

Release 3c (2017 February)

+ +
    + +
  • +Added optional rounding mode odd (round to odd, also known as +jamming). + +
  • +Corrected the documentation concerning non-canonical representations in +80-bit double-extended-precision. + +
+ + +

Release 3b (2016 July)

+ +
    + +
  • +Implemented the common 16-bit “half-precision” +floating-point format (float16_t). + +
  • +Made the integer values returned on invalid conversions to integer formats +be determined by the port-specific specialization instead of being the same for +all ports. + +
  • +Added preprocessor macro THREAD_LOCAL to allow the floating-point +state (modes and exception flags) to be made per-thread. + +
  • +Modified the provided Makefiles to allow some options to be overridden from the +make command. + +
  • +Made other minor improvements. + +
+ + +

Release 3a (2015 October)

+ +
    + +
  • +Replaced the license text supplied by the University of California, Berkeley. + +
+ + +

Release 3 (2015 February)

+ +
    + +
  • +Complete rewrite, funded by the University of California, Berkeley, and +consequently having a different use license than earlier releases. +Major changes included renaming most types and functions, upgrading some +algorithms, restructuring the source files, and making SoftFloat into a true +library. + +
  • +Added functions to convert between floating-point and unsigned integers, both +32-bit and 64-bit (uint32_t and +uint64_t). + +
  • +Added functions for fused multiply-add, for all supported floating-point +formats except 80-bit double-extended-precision. + +
  • +Added support for a fifth rounding mode, near_maxMag (round to +nearest, with ties to maximum magnitude, away from zero). + +
  • +Dropped the timesoftfloat program (now part of the Berkeley +TestFloat package). + +
+ + +

Release 2c (2015 January)

+ +
    + +
  • +Fixed mistakes affecting some 64-bit processors. + +
  • +Further improved the documentation and the wording for the legal restrictions +on using SoftFloat releases through 2c (not applicable to +Release 3 or later). + +
+ + +

Release 2b (2002 May)

+ +
    + +
  • +Made minor updates to the documentation, including improved wording for the +legal restrictions on using SoftFloat. + +
+ + +

Release 2a (1998 December)

+ +
    + +
  • +Added functions to convert between 64-bit integers +(int64) and all supported floating-point formats. + +
  • +Fixed a bug in all 64-bit-version square root functions except +float32_sqrt that caused the result sometimes to be off by +1 unit in the last place (1 ulp) from what it should +be. +(Bug discovered by Paul Donahue.) + +
  • +Improved the Makefiles. +
+ + +

Release 2 (1997 June)

+ +
    + +
  • +Created the 64-bit (bits64) version, adding the +floatx80 and float128 formats. + +
  • +Changed the source directory structure, splitting the sources into a +bits32 and a bits64 version. +Renamed environment.h to milieu.h to avoid confusion +with environment variables. + +
  • +Fixed a small error that caused float64_round_to_int often to +round the wrong way in nearest/even mode when the operand was between +220 and 221 and halfway between two integers. + +
+ + +

Release 1a (1996 July)

+ +
    + +
  • +Corrected a mistake that caused borderline underflow cases not to raise the +underflow flag when they should have. +(Problem reported by Doug Priest.) + +
  • +Added the float_detect_tininess variable to control whether +tininess is detected before or after rounding. + +
+ + +

Release 1 (1996 July)

+ +
    + +
  • +Original release, based on work done for the International Computer Science +Institute (ICSI) in Berkeley, California. + +
+ + + + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-source.html b/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-source.html new file mode 100644 index 000000000..d4b85f7b0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat-source.html @@ -0,0 +1,686 @@ + + + + +Berkeley SoftFloat Source Documentation + + + + +

Berkeley SoftFloat Release 3e: Source Documentation

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Contents

+ +
+ +++ + + + + + + + + + + + + + + + + + + + +
1. Introduction
2. Limitations
3. Acknowledgments and License
4. SoftFloat Package Directory Structure
5. Issues for Porting SoftFloat to a New Target
5.1. Standard Headers <stdbool.h> and + <stdint.h>
5.2. Specializing Floating-Point Behavior
5.3. Macros for Build Options
5.4. Adapting a Template Target Directory
5.5. Target-Specific Optimization of Primitive Functions
6. Testing SoftFloat
7. Providing SoftFloat as a Common Library for Applications
8. Contact Information
+
+ + +

1. Introduction

+ +

+This document gives information needed for compiling and/or porting Berkeley +SoftFloat, a library of C functions implementing binary floating-point +conforming to the IEEE Standard for Floating-Point Arithmetic. +For basic documentation about SoftFloat refer to +SoftFloat.html. +

+ +

+The source code for SoftFloat is intended to be relatively machine-independent +and should be compilable with any ISO-Standard C compiler that also supports +64-bit integers. +SoftFloat has been successfully compiled with the GNU C Compiler +(gcc) for several platforms. +

+ +

+Release 3 of SoftFloat was a complete rewrite relative to +Release 2 or earlier. +Changes to the interface of SoftFloat functions are documented in +SoftFloat.html. +The current version of SoftFloat is Release 3e. +

+ + +

2. Limitations

+ +

+SoftFloat assumes the computer has an addressable byte size of either 8 or +16 bits. +(Nearly all computers in use today have 8-bit bytes.) +

+ +

+SoftFloat is written in C and is designed to work with other C code. +The C compiler used must conform at a minimum to the 1989 ANSI standard for the +C language (same as the 1990 ISO standard) and must in addition support basic +arithmetic on 64-bit integers. +Earlier releases of SoftFloat included implementations of 32-bit +single-precision and 64-bit double-precision floating-point that +did not require 64-bit integers, but this option is not supported +starting with Release 3. +Since 1999, ISO standards for C have mandated compiler support for +64-bit integers. +A compiler conforming to the 1999 C Standard or later is recommended but not +strictly required. +

+ +

+C Standard header files <stdbool.h> and +<stdint.h> are required for defining standard Boolean and +integer types. +If these headers are not supplied with the C compiler, minimal substitutes must +be provided. +SoftFloat’s dependence on these headers is detailed later in +section 5.1, Standard Headers <stdbool.h> +and <stdint.h>. +

+ + +

3. Acknowledgments and License

+ +

+The SoftFloat package was written by me, John R. Hauser. +Release 3 of SoftFloat was a completely new implementation +supplanting earlier releases. +The project to create Release 3 (now through 3e) was +done in the employ of the University of California, Berkeley, within the +Department of Electrical Engineering and Computer Sciences, first for the +Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab. +The work was officially overseen by Prof. Krste Asanovic, with funding provided +by these sources: +

+ ++++ + + + + + + + + + +
Par Lab: +Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery +(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia, +NVIDIA, Oracle, and Samsung. +
ASPIRE Lab: +DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from +ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA, +Oracle, and Samsung. +
+
+

+ +

+The following applies to the whole of SoftFloat Release 3e as well +as to each source file individually. +

+ +

+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. +All rights reserved. +

+ +

+Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +

    + +
  1. +

    +Redistributions of source code must retain the above copyright notice, this +list of conditions, and the following disclaimer. +

    + +
  2. +

    +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions, and the following disclaimer in the documentation and/or +other materials provided with the distribution. +

    + +
  3. +

    +Neither the name of the University nor the names of its contributors may be +used to endorse or promote products derived from this software without specific +prior written permission. +

    + +
+

+ +

+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS “AS IS”, +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. +IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +

+ + +

4. SoftFloat Package Directory Structure

+ +

+Because SoftFloat is targeted to multiple platforms, its source code is +slightly scattered between target-specific and target-independent directories +and files. +The supplied directory structure is as follows: +

+
+doc
+source
+    include
+    8086
+    8086-SSE
+    ARM-VFPv2
+    ARM-VFPv2-defaultNaN
+build
+    template-FAST_INT64
+    template-not-FAST_INT64
+    Linux-386-GCC
+    Linux-386-SSE2-GCC
+    Linux-x86_64-GCC
+    Linux-ARM-VFPv2-GCC
+    Win32-MinGW
+    Win32-SSE2-MinGW
+    Win64-MinGW-w64
+
+
+The majority of the SoftFloat sources are provided in the source +directory. +The include subdirectory contains several header files +(unsurprisingly), while the other subdirectories of source contain +source files that specialize the floating-point behavior to match particular +processor families: +
+
+
8086
+
+Intel’s older, 8087-derived floating-point, extended to all supported +floating-point types +
+
8086-SSE
+
+Intel’s x86 processors with Streaming SIMD Extensions (SSE) and later +compatible extensions, having 8087 behavior for 80-bit +double-extended-precision (extFloat80_t) and SSE behavior for +other floating-point types +
+
ARM-VFPv2
+
+ARM’s VFPv2 or later floating-point, with NaN payload propagation +
+
ARM-VFPv2-defaultNaN
+
+ARM’s VFPv2 or later floating-point, with the “default NaN” +option +
+
+
+If other specializations are attempted, these would be expected to be other +subdirectories of source alongside the ones listed above. +Specialization is covered later, in section 5.2, Specializing +Floating-Point Behavior. +

+ +

+The build directory is intended to contain a subdirectory for each +target platform for which a build of the SoftFloat library may be created. +For each build target, the target’s subdirectory is where all derived +object files and the completed SoftFloat library (typically +softfloat.a or libsoftfloat.a) are created. +The two template subdirectories are not actual build targets but +contain sample files for creating new target directories. +(The meaning of FAST_INT64 will be explained later.) +

+ +

+Ignoring the template directories, the supplied target directories +are intended to follow a naming system of +<execution-environment>-<compiler>. +For the example targets, +<execution-environment> is +Linux-386, Linux-386-SSE2, +Linux-x86_64, +Linux-ARM-VFPv2, Win32, +Win32-SSE2, or Win64, and +<compiler> is GCC, +MinGW, or MinGW-w64. +

+ +

+All of the supplied target directories are merely examples that may or may not +be correct for compiling on any particular system. +Despite requests, there are currently no plans to include and maintain in the +SoftFloat package the build files needed for a great many users’ +compilation environments, which can span a huge range of operating systems, +compilers, and other tools. +

+ +

+As supplied, each target directory contains two files: +

+
+Makefile
+platform.h
+
+
+The provided Makefile is written for GNU make. +A build of SoftFloat for the specific target is begun by executing the +make command with the target directory as the current directory. +A completely different build tool can be used if an appropriate +Makefile equivalent is created. +

+ +

+The platform.h header file exists to provide a location for +additional C declarations specific to the build target. +Every C source file of SoftFloat contains a #include for +platform.h. +In many cases, the contents of platform.h can be as simple as one +or two lines of code. +At the other extreme, to get maximal performance from SoftFloat, it may be +desirable to include in header platform.h (directly or via +#include) declarations for numerous target-specific optimizations. +Such possibilities are discussed in the next section, Issues for Porting +SoftFloat to a New Target. +If the target’s compiler or library has bugs or other shortcomings, +workarounds for these issues may also be possible with target-specific +declarations in platform.h, avoiding the need to modify the main +SoftFloat sources. +

+ + +

5. Issues for Porting SoftFloat to a New Target

+ +

5.1. Standard Headers <stdbool.h> and <stdint.h>

+ +

+The SoftFloat sources make use of standard headers +<stdbool.h> and <stdint.h>, which have +been part of the ISO C Standard Library since 1999. +With any recent compiler, these standard headers are likely to be supported, +even if the compiler does not claim complete conformance to the latest ISO C +Standard. +For older or nonstandard compilers, substitutes for +<stdbool.h> and <stdint.h> may need to be +created. +SoftFloat depends on these names from <stdbool.h>: +

+
+bool
+true
+false
+
+
+and on these names from <stdint.h>: +
+
+uint16_t
+uint32_t
+uint64_t
+int32_t
+int64_t
+UINT64_C
+INT64_C
+uint_least8_t
+uint_fast8_t
+uint_fast16_t
+uint_fast32_t
+uint_fast64_t
+int_fast8_t
+int_fast16_t
+int_fast32_t
+int_fast64_t
+
+
+

+ + +

5.2. Specializing Floating-Point Behavior

+ +

+The IEEE Floating-Point Standard allows for some flexibility in a conforming +implementation, particularly concerning NaNs. +The SoftFloat source directory is supplied with some +specialization subdirectories containing possible definitions for this +implementation-specific behavior. +For example, the 8086 and 8086-SSE +subdirectories have source files that specialize SoftFloat’s behavior to +match that of Intel’s x86 line of processors. +The files in a specialization subdirectory must determine: +

    +
  • +whether tininess for underflow is detected before or after rounding by default; +
  • +how signaling NaNs are distinguished from quiet NaNs; +
  • +what (if anything) special happens when exceptions are raised; +
  • +the default generated quiet NaNs; +
  • +how NaNs are propagated from function inputs to output; and +
  • +the integer results returned when conversions to integer type raise the +invalid exception. +
+

+ +

+As provided, the build process for a target expects to involve exactly +one specialization directory that defines all of these +implementation-specific details for the target. +A specialization directory such as 8086 is expected to contain a +header file called specialize.h, together with whatever other +source files are needed to complete the specialization. +

+ +

+A new build target may use an existing specialization, such as the ones +provided by the 8086 and 8086-SSE +subdirectories. +If a build target needs a new specialization, different from any existing ones, +it is recommended that a new specialization directory be created for this +purpose. +The specialize.h header file from any of the provided +specialization subdirectories can be used as a model for what definitions are +needed. +

+ + +

5.3. Macros for Build Options

+ +

+The SoftFloat source files adapt the floating-point implementation according to +several C preprocessor macros: +

+
+
LITTLEENDIAN +
+Must be defined for little-endian machines; must not be defined for big-endian +machines. +
INLINE +
+Specifies the sequence of tokens used to indicate that a C function should be +inlined. +If macro INLINE_LEVEL is defined with a value of 1 or higher, this +macro must be defined; otherwise, this macro is ignored and need not be +defined. +For compilers that conform to the C Standard’s rules for inline +functions, this macro can be defined as the single keyword inline. +For other compilers that follow a convention pre-dating the standardization of +inline, this macro may need to be defined to extern +inline. +
THREAD_LOCAL +
+Can be defined to a sequence of tokens that, when appearing at the start of a +variable declaration, indicates to the C compiler that the variable is +per-thread, meaning that each execution thread gets its own separate +instance of the variable. +This macro is used in header softfloat.h in the declarations of +variables softfloat_roundingMode, +softfloat_detectTininess, extF80_roundingPrecision, +and softfloat_exceptionFlags. +If macro THREAD_LOCAL is left undefined, these variables will +default to being ordinary global variables. +Depending on the compiler, possible valid definitions of this macro include +_Thread_local and __thread. +
+
+
SOFTFLOAT_ROUND_ODD +
+Can be defined to enable support for optional rounding mode +softfloat_round_odd. +
+
+
INLINE_LEVEL +
+Can be defined to an integer to determine the degree of inlining requested of +the compiler. +Larger numbers request that more inlining be done. +If this macro is not defined or is defined to a value less than 1 +(zero or negative), no inlining is requested. +The maximum effective value is no higher than 5. +Defining this macro to a value greater than 5 is the same as defining it +to 5. +
SOFTFLOAT_FAST_INT64 +
+Can be defined to indicate that the build target’s implementation of +64-bit arithmetic is efficient. +For newer 64-bit processors, this macro should usually be defined. +For very small microprocessors whose buses and registers are 8-bit +or 16-bit in size, this macro should usually not be defined. +Whether this macro should be defined for a 32-bit processor may +depend on the target machine and the applications that will use SoftFloat. +
SOFTFLOAT_FAST_DIV32TO16 +
+Can be defined to indicate that the target’s division operator +in C (written as /) is reasonably efficient for +dividing a 32-bit unsigned integer by a 16-bit +unsigned integer. +Setting this macro may affect the performance of function f16_div. +
SOFTFLOAT_FAST_DIV64TO32 +
+Can be defined to indicate that the target’s division operator +in C (written as /) is reasonably efficient for +dividing a 64-bit unsigned integer by a 32-bit +unsigned integer. +Setting this macro may affect the performance of division, remainder, and +square root operations other than f16_div. +
+
+

+ +

+Following the usual custom for C, for most of these macros (all +except INLINE, THREAD_LOCAL, and +INLINE_LEVEL), the content of any definition is irrelevant; +what matters is a macro’s effect on #ifdef directives. +

+ +

+It is recommended that any definitions of macros LITTLEENDIAN, +INLINE, and THREAD_LOCAL be made in a build +target’s platform.h header file, because these macros are +expected to be determined inflexibly by the target machine and compiler. +The other five macros select options and control optimization, and thus might +be better located in the target’s Makefile (or its equivalent). +

+ + +

5.4. Adapting a Template Target Directory

+ +

+In the build directory, two template subdirectories +provide models for new target directories. +Two different templates exist because different functions are needed in the +SoftFloat library depending on whether macro SOFTFLOAT_FAST_INT64 +is defined. +If macro SOFTFLOAT_FAST_INT64 will be defined, +template-FAST_INT64 is the template to use; +otherwise, template-not-FAST_INT64 is the appropriate +template. +A new target directory can be created by copying the correct template directory +and editing the files inside. +To avoid confusion, it would be wise to refrain from editing the files within a +template directory directly. +

+ + +

5.5. Target-Specific Optimization of Primitive Functions

+ +

+Header file primitives.h (in directory +source/include) declares macros and functions for numerous +underlying arithmetic operations upon which many of SoftFloat’s +floating-point functions are ultimately built. +The SoftFloat sources include implementations of all of these functions/macros, +written as standard C code, so a complete and correct SoftFloat library can be +created using only the supplied code for all functions. +However, for many targets, SoftFloat’s performance can be improved by +substituting target-specific implementations of some of the functions/macros +declared in primitives.h. +

+ +

+For example, primitives.h declares a function called +softfloat_countLeadingZeros32 that takes an unsigned +32-bit integer as an argument and returns the number of the +integer’s most-significant bits that are zeros. +While the SoftFloat sources include an implementation of this function written +in standard C, many processors can perform this same function +directly in only one or two machine instructions. +An alternative, target-specific implementation that maps to those instructions +is likely to be more efficient than the generic C code from the SoftFloat +package. +

+ +

+A build target can replace the supplied version of any function or macro of +primitives.h by defining a macro with the same name in the +target’s platform.h header file. +For this purpose, it may be helpful for platform.h to +#include header file primitiveTypes.h, which defines +types used for arguments and results of functions declared in +primitives.h. +When a desired replacement implementation is a function, not a macro, it is +sufficient for platform.h to include the line +

+
+#define <function-name> <function-name>
+
+
+where <function-name> is the name of the +function. +This technically defines <function-name> +as a macro, but one that resolves to the same name, which may then be a +function. +(A preprocessor that conforms to the C Standard is required to limit recursive +macro expansion from being applied more than once.) +

+ +

+The supplied header file opts-GCC.h (in directory +source/include) provides an example of target-specific +optimization for the GCC compiler. +Each GCC target example in the build directory has +

+#include "opts-GCC.h" +
+in its platform.h header file. +Before opts-GCC.h is included, the following macros must be +defined (or not) to control which features are invoked: +
+
+
SOFTFLOAT_BUILTIN_CLZ
+
+If defined, SoftFloat’s internal +‘countLeadingZeros’ functions use intrinsics +__builtin_clz and __builtin_clzll. +
+
SOFTFLOAT_INTRINSIC_INT128
+
+If defined, SoftFloat makes use of GCC’s nonstandard 128-bit +integer type __int128. +
+
+
+On some machines, these improvements are observed to increase the speeds of +f64_mul and f128_mul by around 20 to 25%, although +other functions receive less dramatic boosts, or none at all. +Results can vary greatly across different platforms. +

+ + +

6. Testing SoftFloat

+ +

+SoftFloat can be tested using the testsoftfloat program by the +same author. +This program is part of the Berkeley TestFloat package available at the Web +page +http://www.jhauser.us/arithmetic/TestFloat.html. +The TestFloat package also has a program called timesoftfloat that +measures the speed of SoftFloat’s floating-point functions. +

+ + +

7. Providing SoftFloat as a Common Library for Applications

+ +

+Header file softfloat.h defines the SoftFloat interface as seen by +clients. +If the SoftFloat library will be made a common library for programs on a +system, the supplied softfloat.h has a couple of deficiencies for +this purpose: +

    +
  • +As supplied, softfloat.h depends on another header, +softfloat_types.h, that is not intended for public use but which +must also be visible to the programmer’s compiler. +
  • +More troubling, at the time softfloat.h is included in a C source +file, macros SOFTFLOAT_FAST_INT64 and THREAD_LOCAL +must be defined, or not defined, consistent with how these macro were defined +when the SoftFloat library was built. +
+In the situation that new programs may regularly #include header +file softfloat.h, it is recommended that a custom, self-contained +version of this header file be created that eliminates these issues. +

+ + +

8. Contact Information

+ +

+At the time of this writing, the most up-to-date information about SoftFloat +and the latest release can be found at the Web page +http://www.jhauser.us/arithmetic/SoftFloat.html. +

+ + + + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat.html b/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat.html new file mode 100644 index 000000000..bb41770ec --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/doc/SoftFloat.html @@ -0,0 +1,1527 @@ + + + + +Berkeley SoftFloat Library Interface + + + + +

Berkeley SoftFloat Release 3e: Library Interface

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Contents

+ +
+ +++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
1. Introduction
2. Limitations
3. Acknowledgments and License
4. Types and Functions
4.1. Boolean and Integer Types
4.2. Floating-Point Types
4.3. Supported Floating-Point Functions
4.4. Non-canonical Representations in extFloat80_t
4.5. Conventions for Passing Arguments and Results
5. Reserved Names
6. Mode Variables
6.1. Rounding Mode
6.2. Underflow Detection
6.3. Rounding Precision for the 80-Bit Extended Format
7. Exceptions and Exception Flags
8. Function Details
8.1. Conversions from Integer to Floating-Point
8.2. Conversions from Floating-Point to Integer
8.3. Conversions Among Floating-Point Types
8.4. Basic Arithmetic Functions
8.5. Fused Multiply-Add Functions
8.6. Remainder Functions
8.7. Round-to-Integer Functions
8.8. Comparison Functions
8.9. Signaling NaN Test Functions
8.10. Raise-Exception Function
9. Changes from SoftFloat Release 2
9.1. Name Changes
9.2. Changes to Function Arguments
9.3. Added Capabilities
9.4. Better Compatibility with the C Language
9.5. New Organization as a Library
9.6. Optimization Gains (and Losses)
10. Future Directions
11. Contact Information
+
+ + +

1. Introduction

+ +

+Berkeley SoftFloat is a software implementation of binary floating-point that +conforms to the IEEE Standard for Floating-Point Arithmetic. +The current release supports five binary formats: 16-bit +half-precision, 32-bit single-precision, 64-bit +double-precision, 80-bit double-extended-precision, and +128-bit quadruple-precision. +The following functions are supported for each format: +

    +
  • +addition, subtraction, multiplication, division, and square root; +
  • +fused multiply-add as defined by the IEEE Standard, except for +80-bit double-extended-precision; +
  • +remainder as defined by the IEEE Standard; +
  • +round to integral value; +
  • +comparisons; +
  • +conversions to/from other supported formats; and +
  • +conversions to/from 32-bit and 64-bit integers, +signed and unsigned. +
+All operations required by the original 1985 version of the IEEE Floating-Point +Standard are implemented, except for conversions to and from decimal. +

+ +

+This document gives information about the types defined and the routines +implemented by SoftFloat. +It does not attempt to define or explain the IEEE Floating-Point Standard. +Information about the standard is available elsewhere. +

+ +

+The current version of SoftFloat is Release 3e. +This release modifies the behavior of the rarely used odd rounding mode +(round to odd, also known as jamming), and also adds some new +specialization and optimization examples for those compiling SoftFloat. +

+ +

+The previous Release 3d fixed bugs that were found in the square +root functions for the 64-bit, 80-bit, and +128-bit floating-point formats. +(Thanks to Alexei Sibidanov at the University of Victoria for reporting an +incorrect result.) +The bugs affected all prior Release-3 versions of SoftFloat +through 3c. +The flaw in the 64-bit floating-point square root function was of +very minor impact, causing a 1-ulp error (1 unit in +the last place) a few times out of a billion. +The bugs in the 80-bit and 128-bit square root +functions were more serious. +Although incorrect results again occurred only a few times out of a billion, +when they did occur a large portion of the less-significant bits could be +wrong. +

+ +

+Among earlier releases, 3b was notable for adding support for the +16-bit half-precision format. +For more about the evolution of SoftFloat releases, see +SoftFloat-history.html. +

+ +

+The functional interface of SoftFloat Release 3 and later differs +in many details from the releases that came before. +For specifics of these differences, see section 9 below, +Changes from SoftFloat Release 2. +

+ + +

2. Limitations

+ +

+SoftFloat assumes the computer has an addressable byte size of 8 or +16 bits. +(Nearly all computers in use today have 8-bit bytes.) +

+ +

+SoftFloat is written in C and is designed to work with other C code. +The C compiler used must conform at a minimum to the 1989 ANSI standard for the +C language (same as the 1990 ISO standard) and must in addition support basic +arithmetic on 64-bit integers. +Earlier releases of SoftFloat included implementations of 32-bit +single-precision and 64-bit double-precision floating-point that +did not require 64-bit integers, but this option is not supported +starting with Release 3. +Since 1999, ISO standards for C have mandated compiler support for +64-bit integers. +A compiler conforming to the 1999 C Standard or later is recommended but not +strictly required. +

+ +

+Most operations not required by the original 1985 version of the IEEE +Floating-Point Standard but added in the 2008 version are not yet supported in +SoftFloat Release 3e. +

+ + +

3. Acknowledgments and License

+ +

+The SoftFloat package was written by me, John R. Hauser. +Release 3 of SoftFloat was a completely new implementation +supplanting earlier releases. +The project to create Release 3 (now through 3e) was +done in the employ of the University of California, Berkeley, within the +Department of Electrical Engineering and Computer Sciences, first for the +Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab. +The work was officially overseen by Prof. Krste Asanovic, with funding provided +by these sources: +

+ ++++ + + + + + + + + + +
Par Lab: +Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery +(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia, +NVIDIA, Oracle, and Samsung. +
ASPIRE Lab: +DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from +ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA, +Oracle, and Samsung. +
+
+

+ +

+The following applies to the whole of SoftFloat Release 3e as well +as to each source file individually. +

+ +

+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. +All rights reserved. +

+ +

+Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +

    + +
  1. +

    +Redistributions of source code must retain the above copyright notice, this +list of conditions, and the following disclaimer. +

    + +
  2. +

    +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions, and the following disclaimer in the documentation and/or +other materials provided with the distribution. +

    + +
  3. +

    +Neither the name of the University nor the names of its contributors may be +used to endorse or promote products derived from this software without specific +prior written permission. +

    + +
+

+ +

+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS “AS IS”, +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. +IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +

+ + +

4. Types and Functions

+ +

+The types and functions of SoftFloat are declared in header file +softfloat.h. +

+ +

4.1. Boolean and Integer Types

+ +

+Header file softfloat.h depends on standard headers +<stdbool.h> and <stdint.h> to define type +bool and several integer types. +These standard headers have been part of the ISO C Standard Library since 1999. +With any recent compiler, they are likely to be supported, even if the compiler +does not claim complete conformance to the latest ISO C Standard. +For older or nonstandard compilers, a port of SoftFloat may have substitutes +for these headers. +Header softfloat.h depends only on the name bool from +<stdbool.h> and on these type names from +<stdint.h>: +

+
+uint16_t
+uint32_t
+uint64_t
+int32_t
+int64_t
+uint_fast8_t
+uint_fast32_t
+uint_fast64_t
+int_fast32_t
+int_fast64_t
+
+
+

+ + +

4.2. Floating-Point Types

+ +

+The softfloat.h header defines five floating-point types: +

+ + + + + + + + + + + + + + + + + + + + + +
float16_t16-bit half-precision binary format
float32_t32-bit single-precision binary format
float64_t64-bit double-precision binary format
extFloat80_t   80-bit double-extended-precision binary format (old Intel or +Motorola format)
float128_t128-bit quadruple-precision binary format
+
+The non-extended types are each exactly the size specified: +16 bits for float16_t, 32 bits for +float32_t, 64 bits for float64_t, and +128 bits for float128_t. +Aside from these size requirements, the definitions of all these types may +differ for different ports of SoftFloat to specific systems. +A given port of SoftFloat may or may not define some of the floating-point +types as aliases for the C standard types float, +double, and long double. +

+ +

+Header file softfloat.h also defines a structure, +struct extFloat80M, for the representation of +80-bit double-extended-precision floating-point values in memory. +This structure is the same size as type extFloat80_t and contains +at least these two fields (not necessarily in this order): +

+
+uint16_t signExp;
+uint64_t signif;
+
+
+Field signExp contains the sign and exponent of the floating-point +value, with the sign in the most significant bit (bit 15) and the +encoded exponent in the other 15 bits. +Field signif is the complete 64-bit significand of +the floating-point value. +(In the usual encoding for 80-bit extended floating-point, the +leading 1 bit of normalized numbers is not implicit but is stored +in the most significant bit of the significand.) +

+ +

4.3. Supported Floating-Point Functions

+ +

+SoftFloat implements these arithmetic operations for its floating-point types: +

    +
  • +conversions between any two floating-point formats; +
  • +for each floating-point format, conversions to and from signed and unsigned +32-bit and 64-bit integers; +
  • +for each format, the usual addition, subtraction, multiplication, division, and +square root operations; +
  • +for each format except extFloat80_t, the fused multiply-add +operation defined by the IEEE Standard; +
  • +for each format, the floating-point remainder operation defined by the IEEE +Standard; +
  • +for each format, a “round to integer” operation that rounds to the +nearest integer value in the same format; and +
  • +comparisons between two values in the same floating-point format. +
+

+ +

+The following operations required by the 2008 IEEE Floating-Point Standard are +not supported in SoftFloat Release 3e: +

    +
  • +nextUp, nextDown, minNum, maxNum, minNumMag, +maxNumMag, scaleB, and logB; +
  • +conversions between floating-point formats and decimal or hexadecimal character +sequences; +
  • +all “quiet-computation” operations (copy, negate, +abs, and copySign, which all involve only simple copying and/or +manipulation of the floating-point sign bit); and +
  • +all “non-computational” operations other than isSignaling +(which is supported). +
+

+ +

4.4. Non-canonical Representations in extFloat80_t

+ +

+Because the 80-bit double-extended-precision format, +extFloat80_t, stores an explicit leading significand bit, many +finite floating-point numbers are encodable in this type in multiple equivalent +forms. +Of these multiple encodings, there is always a unique one with the least +encoded exponent value, and this encoding is considered the canonical +representation of the floating-point number. +Any other equivalent representations (having a higher encoded exponent value) +are non-canonical. +For a value in the subnormal range (including zero), the canonical +representation always has an encoded exponent of zero and a leading significand +bit of 0. +For finite values outside the subnormal range, the canonical representation +always has an encoded exponent that is nonzero and a leading significand bit +of 1. +

+ +

+For an infinity or NaN, the leading significand bit is similarly expected to +be 1. +An infinity or NaN with a leading significand bit of 0 is again +considered non-canonical. +Hence, altogether, to be canonical, a value of type extFloat80_t +must have a leading significand bit of 1, unless the value is +subnormal or zero, in which case the leading significand bit and the encoded +exponent must both be zero. +

+ +

+SoftFloat’s functions are not guaranteed to operate as expected when +inputs of type extFloat80_t are non-canonical. +Assuming all of a function’s extFloat80_t inputs (if any) +are canonical, function outputs of type extFloat80_t will always +be canonical. +

+ +

4.5. Conventions for Passing Arguments and Results

+ +

+Values that are at most 64 bits in size (i.e., not the +80-bit or 128-bit floating-point formats) are in all +cases passed as function arguments by value. +Likewise, when an output of a function is no more than 64 bits, it +is always returned directly as the function result. +Thus, for example, the SoftFloat function for adding two 64-bit +floating-point values has this simple signature: +

+float64_t f64_add( float64_t, float64_t ); +
+

+ +

+The story is more complex when function inputs and outputs are +80-bit and 128-bit floating-point. +For these types, SoftFloat always provides a function that passes these larger +values into or out of the function indirectly, via pointers. +For example, for adding two 128-bit floating-point values, +SoftFloat supplies this function: +

+void f128M_add( const float128_t *, const float128_t *, float128_t * ); +
+The first two arguments point to the values to be added, and the last argument +points to the location where the sum will be stored. +The M in the name f128M_add is mnemonic for the fact +that the 128-bit inputs and outputs are “in memory”, +pointed to by pointer arguments. +

+ +

+All ports of SoftFloat implement these pass-by-pointer functions for +types extFloat80_t and float128_t. +At the same time, SoftFloat ports may also implement alternate versions of +these same functions that pass extFloat80_t and +float128_t by value, like the smaller formats. +Thus, besides the function with name f128M_add shown above, a +SoftFloat port may also supply an equivalent function with this signature: +

+float128_t f128_add( float128_t, float128_t ); +
+

+ +

+As a general rule, on computers where the machine word size is +32 bits or smaller, only the pass-by-pointer versions of functions +(e.g., f128M_add) are provided for types extFloat80_t +and float128_t, because passing such large types directly can have +significant extra cost. +On computers where the word size is 64 bits or larger, both +function versions (f128M_add and f128_add) are +provided, because the cost of passing by value is then more reasonable. +Applications that must be portable accross both classes of computers must use +the pointer-based functions, as these are always implemented. +However, if it is known that SoftFloat includes the by-value functions for all +platforms of interest, programmers can use whichever version they prefer. +

+ + +

5. Reserved Names

+ +

+In addition to the variables and functions documented here, SoftFloat defines +some symbol names for its own private use. +These private names always begin with the prefix +‘softfloat_’. +When a program includes header softfloat.h or links with the +SoftFloat library, all names with prefix ‘softfloat_’ +are reserved for possible use by SoftFloat. +Applications that use SoftFloat should not define their own names with this +prefix, and should reference only such names as are documented. +

+ + +

6. Mode Variables

+ +

+The following global variables control rounding mode, underflow detection, and +the 80-bit extended format’s rounding precision: +

+softfloat_roundingMode
+softfloat_detectTininess
+extF80_roundingPrecision +
+These mode variables are covered in the next several subsections. +For some SoftFloat ports, these variables may be per-thread (declared +thread_local), meaning that different execution threads have their +own separate copies of the variables. +

+ +

6.1. Rounding Mode

+ +

+All five rounding modes defined by the 2008 IEEE Floating-Point Standard are +implemented for all operations that require rounding. +Some ports of SoftFloat may also implement the round-to-odd mode. +

+ +

+The rounding mode is selected by the global variable +

+uint_fast8_t softfloat_roundingMode; +
+This variable may be set to one of the values +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
softfloat_round_near_evenround to nearest, with ties to even
softfloat_round_near_maxMag  round to nearest, with ties to maximum magnitude (away from zero)
softfloat_round_minMaground to minimum magnitude (toward zero)
softfloat_round_minround to minimum (down)
softfloat_round_maxround to maximum (up)
softfloat_round_oddround to odd (jamming), if supported by the SoftFloat port
+
+Variable softfloat_roundingMode is initialized to +softfloat_round_near_even. +

+ +

+When softfloat_round_odd is the rounding mode for a function that +rounds to an integer value (either conversion to an integer format or a +‘roundToInt’ function), if the input is not already an +integer, the rounded result is the closest odd integer. +For other operations, this rounding mode acts as though the floating-point +result is first rounded to minimum magnitude, the same as +softfloat_round_minMag, and then, if the result is inexact, the +least-significant bit of the result is set to 1. +Rounding to odd is also known as jamming. +

+ +

6.2. Underflow Detection

+ +

+In the terminology of the IEEE Standard, SoftFloat can detect tininess for +underflow either before or after rounding. +The choice is made by the global variable +

+uint_fast8_t softfloat_detectTininess; +
+which can be set to either +
+softfloat_tininess_beforeRounding
+softfloat_tininess_afterRounding +
+Detecting tininess after rounding is usually better because it results in fewer +spurious underflow signals. +The other option is provided for compatibility with some systems. +Like most systems (and as required by the newer 2008 IEEE Standard), SoftFloat +always detects loss of accuracy for underflow as an inexact result. +

+ +

6.3. Rounding Precision for the 80-Bit Extended Format

+ +

+For extFloat80_t only, the rounding precision of the basic +arithmetic operations is controlled by the global variable +

+uint_fast8_t extF80_roundingPrecision; +
+The operations affected are: +
+extF80_add
+extF80_sub
+extF80_mul
+extF80_div
+extF80_sqrt +
+When extF80_roundingPrecision is set to its default value of 80, +these operations are rounded to the full precision of the 80-bit +double-extended-precision format, like occurs for other formats. +Setting extF80_roundingPrecision to 32 or to 64 causes the +operations listed to be rounded to 32-bit precision (equivalent to +float32_t) or to 64-bit precision (equivalent to +float64_t), respectively. +When rounding to reduced precision, additional bits in the result significand +beyond the rounding point are set to zero. +The consequences of setting extF80_roundingPrecision to a value +other than 32, 64, or 80 is not specified. +Operations other than the ones listed above are not affected by +extF80_roundingPrecision. +

+ + +

7. Exceptions and Exception Flags

+ +

+All five exception flags required by the IEEE Floating-Point Standard are +implemented. +Each flag is stored as a separate bit in the global variable +

+uint_fast8_t softfloat_exceptionFlags; +
+The positions of the exception flag bits within this variable are determined by +the bit masks +
+softfloat_flag_inexact
+softfloat_flag_underflow
+softfloat_flag_overflow
+softfloat_flag_infinite
+softfloat_flag_invalid +
+Variable softfloat_exceptionFlags is initialized to all zeros, +meaning no exceptions. +

+ +

+For some SoftFloat ports, softfloat_exceptionFlags may be +per-thread (declared thread_local), meaning that different +execution threads have their own separate instances of it. +

+ +

+An individual exception flag can be cleared with the statement +

+softfloat_exceptionFlags &= ~softfloat_flag_<exception>; +
+where <exception> is the appropriate name. +To raise a floating-point exception, function softfloat_raiseFlags +should normally be used. +

+ +

+When SoftFloat detects an exception other than inexact, it calls +softfloat_raiseFlags. +The default version of this function simply raises the corresponding exception +flags. +Particular ports of SoftFloat may support alternate behavior, such as exception +traps, by modifying the default softfloat_raiseFlags. +A program may also supply its own softfloat_raiseFlags function to +override the one from the SoftFloat library. +

+ +

+Because inexact results occur frequently under most circumstances (and thus are +hardly exceptional), SoftFloat does not ordinarily call +softfloat_raiseFlags for inexact exceptions. +It does always raise the inexact exception flag as required. +

+ + +

8. Function Details

+ +

+In this section, <float> appears in function names as +a substitute for one of these abbreviations: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
f16indicates float16_t, passed by value
f32indicates float32_t, passed by value
f64indicates float64_t, passed by value
extF80M   indicates extFloat80_t, passed indirectly via pointers
extF80indicates extFloat80_t, passed by value
f128Mindicates float128_t, passed indirectly via pointers
f128indicates float128_t, passed by value
+
+The circumstances under which values of floating-point types +extFloat80_t and float128_t may be passed either by +value or indirectly via pointers was discussed earlier in +section 4.5, Conventions for Passing Arguments and Results. +

+ +

8.1. Conversions from Integer to Floating-Point

+ +

+All conversions from a 32-bit or 64-bit integer, +signed or unsigned, to a floating-point format are supported. +Functions performing these conversions have these names: +

+ui32_to_<float>
+ui64_to_<float>
+i32_to_<float>
+i64_to_<float> +
+Conversions from 32-bit integers to 64-bit +double-precision and larger formats are always exact, and likewise conversions +from 64-bit integers to 80-bit +double-extended-precision and 128-bit quadruple-precision are also +always exact. +

+ +

+Each conversion function takes one input of the appropriate type and generates +one output. +The following illustrates the signatures of these functions in cases when the +floating-point result is passed either by value or via pointers: +

+
+float64_t i32_to_f64( int32_t a );
+
+
+void i32_to_f128M( int32_t a, float128_t *destPtr );
+
+
+

+ +

8.2. Conversions from Floating-Point to Integer

+ +

+Conversions from a floating-point format to a 32-bit or +64-bit integer, signed or unsigned, are supported with these +functions: +

+<float>_to_ui32
+<float>_to_ui64
+<float>_to_i32
+<float>_to_i64 +
+The functions have signatures as follows, depending on whether the +floating-point input is passed by value or via pointers: +
+
+int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact );
+
+
+int_fast32_t
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact );
+
+
+

+ +

+The roundingMode argument specifies the rounding mode for +the conversion. +The variable that usually indicates rounding mode, +softfloat_roundingMode, is ignored. +Argument exact determines whether the inexact +exception flag is raised if the conversion is not exact. +If exact is true, the inexact flag may +be raised; +otherwise, it will not be, even if the conversion is inexact. +

+ +

+A conversion from floating-point to integer format raises the invalid +exception if the source value cannot be rounded to a representable integer of +the desired size (32 or 64 bits). +In such circumstances, the integer result returned is determined by the +particular port of SoftFloat, although typically this value will be either the +maximum or minimum value of the integer format. +The functions that convert to integer types never raise the floating-point +overflow exception. +

+ +

+Because languages such as C require that conversions to integers +be rounded toward zero, the following functions are provided for improved speed +and convenience: +

+<float>_to_ui32_r_minMag
+<float>_to_ui64_r_minMag
+<float>_to_i32_r_minMag
+<float>_to_i64_r_minMag +
+These functions round only toward zero (to minimum magnitude). +The signatures for these functions are the same as above without the redundant +roundingMode argument: +
+
+int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact );
+
+
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact );
+
+
+

+ +

8.3. Conversions Among Floating-Point Types

+ +

+Conversions between floating-point formats are done by functions with these +names: +

+<float>_to_<float> +
+All combinations of source and result type are supported where the source and +result are different formats. +There are four different styles of signature for these functions, depending on +whether the input and the output floating-point values are passed by value or +via pointers: +
+
+float32_t f64_to_f32( float64_t a );
+
+
+float32_t f128M_to_f32( const float128_t *aPtr );
+
+
+void f32_to_f128M( float32_t a, float128_t *destPtr );
+
+
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *destPtr );
+
+
+

+ +

+Conversions from a smaller to a larger floating-point format are always exact +and so require no rounding. +

+ +

8.4. Basic Arithmetic Functions

+ +

+The following basic arithmetic functions are provided: +

+<float>_add
+<float>_sub
+<float>_mul
+<float>_div
+<float>_sqrt +
+Each floating-point operation takes two operands, except for sqrt +(square root) which takes only one. +The operands and result are all of the same floating-point format. +Signatures for these functions take the following forms: +
+
+float64_t f64_add( float64_t a, float64_t b );
+
+
+void
+ f128M_add(
+     const float128_t *aPtr, const float128_t *bPtr, float128_t *destPtr );
+
+
+float64_t f64_sqrt( float64_t a );
+
+
+void f128M_sqrt( const float128_t *aPtr, float128_t *destPtr );
+
+
+When floating-point values are passed indirectly through pointers, arguments +aPtr and bPtr point to the input +operands, and the last argument, destPtr, points to the +location where the result is stored. +

+ +

+Rounding of the 80-bit double-extended-precision +(extFloat80_t) functions is affected by variable +extF80_roundingPrecision, as explained earlier in +section 6.3, +Rounding Precision for the 80-Bit Extended Format. +

+ +

8.5. Fused Multiply-Add Functions

+ +

+The 2008 version of the IEEE Floating-Point Standard defines a fused +multiply-add operation that does a combined multiplication and addition +with only a single rounding. +SoftFloat implements fused multiply-add with functions +

+<float>_mulAdd +
+Unlike other operations, fused multiple-add is not supported for the +80-bit double-extended-precision format, +extFloat80_t. +

+ +

+Depending on whether floating-point values are passed by value or via pointers, +the fused multiply-add functions have signatures of these forms: +

+
+float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c );
+
+
+void
+ f128M_mulAdd(
+     const float128_t *aPtr,
+     const float128_t *bPtr,
+     const float128_t *cPtr,
+     float128_t *destPtr
+ );
+
+
+The functions compute +(a × b) + + c +with a single rounding. +When floating-point values are passed indirectly through pointers, arguments +aPtr, bPtr, and +cPtr point to operands a, +b, and c respectively, and +destPtr points to the location where the result is stored. +

+ +

+If one of the multiplication operands a and +b is infinite and the other is zero, these functions raise +the invalid exception even if operand c is a quiet NaN. +

+ +

8.6. Remainder Functions

+ +

+For each format, SoftFloat implements the remainder operation defined by the +IEEE Floating-Point Standard. +The remainder functions have names +

+<float>_rem +
+Each remainder operation takes two floating-point operands of the same format +and returns a result in the same format. +Depending on whether floating-point values are passed by value or via pointers, +the remainder functions have signatures of these forms: +
+
+float64_t f64_rem( float64_t a, float64_t b );
+
+
+void
+ f128M_rem(
+     const float128_t *aPtr, const float128_t *bPtr, float128_t *destPtr );
+
+
+When floating-point values are passed indirectly through pointers, arguments +aPtr and bPtr point to operands +a and b respectively, and +destPtr points to the location where the result is stored. +

+ +

+The IEEE Standard remainder operation computes the value +a + − n × b, +where n is the integer closest to +a ÷ b. +If a ÷ b is exactly +halfway between two integers, n is the even integer closest to +a ÷ b. +The IEEE Standard’s remainder operation is always exact and so requires +no rounding. +

+ +

+Depending on the relative magnitudes of the operands, the remainder +functions can take considerably longer to execute than the other SoftFloat +functions. +This is an inherent characteristic of the remainder operation itself and is not +a flaw in the SoftFloat implementation. +

+ +

8.7. Round-to-Integer Functions

+ +

+For each format, SoftFloat implements the round-to-integer operation specified +by the IEEE Floating-Point Standard. +These functions are named +

+<float>_roundToInt +
+Each round-to-integer operation takes a single floating-point operand. +This operand is rounded to an integer according to a specified rounding mode, +and the resulting integer value is returned in the same floating-point format. +(Note that the result is not an integer type.) +

+ +

+The signatures of the round-to-integer functions are similar to those for +conversions to an integer type: +

+
+float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact );
+
+
+void
+ f128M_roundToInt(
+     const float128_t *aPtr,
+     uint_fast8_t roundingMode,
+     bool exact,
+     float128_t *destPtr
+ );
+
+
+When floating-point values are passed indirectly through pointers, +aPtr points to the input operand and +destPtr points to the location where the result is stored. +

+ +

+The roundingMode argument specifies the rounding mode to +apply. +The variable that usually indicates rounding mode, +softfloat_roundingMode, is ignored. +Argument exact determines whether the inexact +exception flag is raised if the conversion is not exact. +If exact is true, the inexact flag may +be raised; +otherwise, it will not be, even if the conversion is inexact. +

+ +

8.8. Comparison Functions

+ +

+For each format, the following floating-point comparison functions are +provided: +

+<float>_eq
+<float>_le
+<float>_lt +
+Each comparison takes two operands of the same type and returns a Boolean. +The abbreviation eq stands for “equal” (=); +le stands for “less than or equal” (≤); +and lt stands for “less than” (<). +Depending on whether the floating-point operands are passed by value or via +pointers, the comparison functions have signatures of these forms: +
+
+bool f64_eq( float64_t a, float64_t b );
+
+
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr );
+
+
+

+ +

+The usual greater-than (>), greater-than-or-equal (≥), and not-equal +(≠) comparisons are easily obtained from the functions provided. +The not-equal function is just the logical complement of the equal function. +The greater-than-or-equal function is identical to the less-than-or-equal +function with the arguments in reverse order, and likewise the greater-than +function is identical to the less-than function with the arguments reversed. +

+ +

+The IEEE Floating-Point Standard specifies that the less-than-or-equal and +less-than comparisons by default raise the invalid exception if either +operand is any kind of NaN. +Equality comparisons, on the other hand, are defined by default to raise the +invalid exception only for signaling NaNs, not quiet NaNs. +For completeness, SoftFloat provides these complementary functions: +

+<float>_eq_signaling
+<float>_le_quiet
+<float>_lt_quiet +
+The signaling equality comparisons are identical to the default +equality comparisons except that the invalid exception is raised for any +NaN input, not just for signaling NaNs. +Similarly, the quiet comparison functions are identical to their +default counterparts except that the invalid exception is not raised for +quiet NaNs. +

+ +

8.9. Signaling NaN Test Functions

+ +

+Functions for testing whether a floating-point value is a signaling NaN are +provided with these names: +

+<float>_isSignalingNaN +
+The functions take one floating-point operand and return a Boolean indicating +whether the operand is a signaling NaN. +Accordingly, the functions have the forms +
+
+bool f64_isSignalingNaN( float64_t a );
+
+
+bool f128M_isSignalingNaN( const float128_t *aPtr );
+
+
+

+ +

8.10. Raise-Exception Function

+ +

+SoftFloat provides a single function for raising floating-point exceptions: +

+
+void softfloat_raiseFlags( uint_fast8_t exceptions );
+
+
+The exceptions argument is a mask indicating the set of +exceptions to raise. +(See earlier section 7, Exceptions and Exception Flags.) +In addition to setting the specified exception flags in variable +softfloat_exceptionFlags, the softfloat_raiseFlags +function may cause a trap or abort appropriate for the current system. +

+ + +

9. Changes from SoftFloat Release 2

+ +

+Apart from a change in the legal use license, Release 3 of +SoftFloat introduced numerous technical differences compared to earlier +releases. +

+ +

9.1. Name Changes

+ +

+The most obvious and pervasive difference compared to Release 2 +is that the names of most functions and variables have changed, even when the +behavior has not. +First, the floating-point types, the mode variables, the exception flags +variable, the function to raise exceptions, and various associated constants +have been renamed as follows: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
old name, Release 2:new name, Release 3:
float32float32_t
float64float64_t
floatx80extFloat80_t
float128float128_t
float_rounding_modesoftfloat_roundingMode
float_round_nearest_evensoftfloat_round_near_even
float_round_to_zerosoftfloat_round_minMag
float_round_downsoftfloat_round_min
float_round_upsoftfloat_round_max
float_detect_tininesssoftfloat_detectTininess
float_tininess_before_rounding    softfloat_tininess_beforeRounding
float_tininess_after_roundingsoftfloat_tininess_afterRounding
floatx80_rounding_precisionextF80_roundingPrecision
float_exception_flagssoftfloat_exceptionFlags
float_flag_inexactsoftfloat_flag_inexact
float_flag_underflowsoftfloat_flag_underflow
float_flag_overflowsoftfloat_flag_overflow
float_flag_divbyzerosoftfloat_flag_infinite
float_flag_invalidsoftfloat_flag_invalid
float_raisesoftfloat_raiseFlags
+
+

+ +

+Furthermore, Release 3 adopted the following new abbreviations for +function names: +

+ + + + + + + + + + + +
used in names in Release 2:    used in names in Release 3:
int32 i32
int64 i64
float32 f32
float64 f64
floatx80 extF80
float128 f128
+
+Thus, for example, the function to add two 32-bit floating-point +numbers, previously called float32_add in Release 2, +is now f32_add. +Lastly, there have been a few other changes to function names: +
+ + + + + + + + + + + + + + + + + + + + + +
used in names in Release 2:   used in names in Release 3:   relevant functions:
_round_to_zero_r_minMagconversions from floating-point to integer (section 8.2)
round_to_introundToIntround-to-integer functions (section 8.7)
is_signaling_nan    isSignalingNaNsignaling NaN test functions (section 8.9)
+
+

+ +

9.2. Changes to Function Arguments

+ +

+Besides simple name changes, some operations were given a different interface +in Release 3 than they had in Release 2: +

    + +
  • +

    +Since Release 3, integer arguments and results of functions have +standard types from header <stdint.h>, such as +uint32_t, whereas previously their types could be defined +differently for each port of SoftFloat, usually using traditional C types such +as unsigned int. +Likewise, functions in Release 3 and later pass Booleans as +standard type bool from <stdbool.h>, whereas +previously these were again passed as a port-specific type (usually +int). +

    + +
  • +

    +As explained earlier in section 4.5, Conventions for Passing +Arguments and Results, SoftFloat functions in Release 3 and +later may pass 80-bit and 128-bit floating-point +values through pointers, meaning that functions take pointer arguments and then +read or write floating-point values at the locations indicated by the pointers. +In Release 2, floating-point arguments and results were always +passed by value, regardless of their size. +

    + +
  • +

    +Functions that round to an integer have additional +roundingMode and exact arguments that +they did not have in Release 2. +Refer to sections 8.2 and 8.7 for descriptions of these functions +since Release 3. +For Release 2, the rounding mode, when needed, was taken from the +same global variable that affects the basic arithmetic operations (now called +softfloat_roundingMode but previously known as +float_rounding_mode). +Also, for Release 2, if the original floating-point input was not +an exact integer value, and if the invalid exception was not raised by +the function, the inexact exception was always raised. +Release 2 had no option to suppress raising inexact in this +case. +Applications using SoftFloat Release 3 or later can get the same +effect as Release 2 by passing variable +softfloat_roundingMode for argument +roundingMode and true for argument +exact. +

    + +
+

+ +

9.3. Added Capabilities

+ +

+With Release 3, some new features have been added that were not +present in Release 2: +

    + +
  • +

    +A port of SoftFloat can now define any of the floating-point types +float32_t, float64_t, extFloat80_t, and +float128_t as aliases for C’s standard floating-point types +float, double, and long +double, using either #define or typedef. +This potential convenience was not supported under Release 2. +

    + +

    +(Note, however, that there may be a performance cost to defining +SoftFloat’s floating-point types this way, depending on the platform and +the applications using SoftFloat. +Ports of SoftFloat may choose to forgo the convenience in favor of better +speed.) +

    + +

    +

  • +As of Release 3b, 16-bit half-precision, +float16_t, is supported. +

    + +

    +

  • +Functions have been added for converting between the floating-point types and +unsigned integers. +Release 2 supported only signed integers, not unsigned. +

    + +

    +

  • +Fused multiply-add functions have been added for all floating-point formats +except 80-bit double-extended-precision, +extFloat80_t. +

    + +

    +

  • +New rounding modes are supported: +softfloat_round_near_maxMag (round to nearest, with ties to +maximum magnitude, away from zero), and, as of Release 3c, +optional softfloat_round_odd (round to odd, also known as +jamming). +

    + +
+

+ +

9.4. Better Compatibility with the C Language

+ +

+Release 3 of SoftFloat was written to conform better to the ISO C +Standard’s rules for portability. +For example, older releases of SoftFloat employed type conversions in ways +that, while commonly practiced, are not fully defined by the C Standard. +Such problematic type conversions have generally been replaced by the use of +unions, the behavior around which is more strictly regulated these days. +

+ +

9.5. New Organization as a Library

+ +

+Starting with Release 3, SoftFloat now builds as a library. +Previously, SoftFloat compiled into a single, monolithic object file containing +all the SoftFloat functions, with the consequence that a program linking with +SoftFloat would get every SoftFloat function in its binary file even if only a +few functions were actually used. +With SoftFloat in the form of a library, a program that is linked by a standard +linker will include only those functions of SoftFloat that it needs and no +others. +

+ +

9.6. Optimization Gains (and Losses)

+ +

+Individual SoftFloat functions have been variously improved in +Release 3 compared to earlier releases. +In particular, better, faster algorithms have been deployed for the operations +of division, square root, and remainder. +For functions operating on the larger 80-bit and +128-bit formats, extFloat80_t and +float128_t, code size has also generally been reduced. +

+ +

+However, because Release 2 compiled all of SoftFloat together as a +single object file, compilers could make optimizations across function calls +when one SoftFloat function calls another. +Now that the functions of SoftFloat are compiled separately and only afterward +linked together into a program, there is not usually the same opportunity to +optimize across function calls. +Some loss of speed has been observed due to this change. +

+ + +

10. Future Directions

+ +

+The following improvements are anticipated for future releases of SoftFloat: +

    +
  • +more functions from the 2008 version of the IEEE Floating-Point Standard; +
  • +consistent, defined behavior for non-canonical representations of extended +format extFloat80_t (discussed in section 4.4, +Non-canonical Representations in extFloat80_t). + +
+

+ + +

11. Contact Information

+ +

+At the time of this writing, the most up-to-date information about SoftFloat +and the latest release can be found at the Web page +http://www.jhauser.us/arithmetic/SoftFloat.html. +

+ + + + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/extF80M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/extF80M_isSignalingNaN.c new file mode 100644 index 000000000..85ee211c2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/extF80M_isSignalingNaN.c @@ -0,0 +1,57 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool extF80M_isSignalingNaN( const extFloat80_t *aPtr ) +{ + const struct extFloat80M *aSPtr; + uint64_t uiA0; + + aSPtr = (const struct extFloat80M *) aPtr; + if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false; + uiA0 = aSPtr->signif; + return + ! (uiA0 & UINT64_C( 0x4000000000000000 )) + && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/f128M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/f128M_isSignalingNaN.c new file mode 100644 index 000000000..79a707771 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/f128M_isSignalingNaN.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool f128M_isSignalingNaN( const float128_t *aPtr ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false; + return + ((uiA96 & 0x00007FFF) != 0) + || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )]) + != 0); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80M.c new file mode 100644 index 000000000..3405b3ba4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80M.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| `zSPtr'. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ) +{ + + zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF ); + zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80UI.c new file mode 100644 index 000000000..cb7424f43 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToExtF80UI.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF; + uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128M.c new file mode 100644 index 000000000..e7ea80258 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128M.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument +| `zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ) +{ + + softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr ); + zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128UI.c new file mode 100644 index 000000000..7a9423bea --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF128UI.c @@ -0,0 +1,55 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 ); + uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 ); + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF16UI.c new file mode 100644 index 000000000..d4e458a94 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF16UI.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr ) +{ + + return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF32UI.c new file mode 100644 index 000000000..ed6c2268f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF32UI.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr ) +{ + + return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF64UI.c new file mode 100644 index 000000000..1182be3c9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_commonNaNToF64UI.c @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr ) +{ + + return + (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 ) + | aPtr->v64>>12; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c new file mode 100644 index 000000000..00baf35f8 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80MToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is +| a NaN, converts this NaN to the common NaN form, and stores the resulting +| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling +| NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80MToCommonNaN( + const struct extFloat80M *aSPtr, struct commonNaN *zPtr ) +{ + + if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = signExtF80UI64( aSPtr->signExp ); + zPtr->v64 = aSPtr->signif<<1; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c new file mode 100644 index 000000000..ab6311ef2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_extF80UIToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0' +| has the bit pattern of an 80-bit extended floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80UIToCommonNaN( + uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA64>>15; + zPtr->v64 = uiA0<<1; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128MToCommonNaN.c new file mode 100644 index 000000000..55ec25b58 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128MToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN, +| converts this NaN to the common NaN form, and stores the resulting common +| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN, +| the invalid exception is raised. Argument `aWPtr' points to an array of +| four 32-bit elements that concatenate in the platform's normal endian order +| to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr ) +{ + + if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = aWPtr[indexWordHi( 4 )]>>31; + softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c new file mode 100644 index 000000000..f838f02aa --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f128UIToCommonNaN.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0' +| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to +| the common NaN form, and stores the resulting common NaN at the location +| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception +| is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_f128UIToCommonNaN( + uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ) +{ + struct uint128 NaNSig; + + if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 ); + zPtr->sign = uiA64>>63; + zPtr->v64 = NaNSig.v64; + zPtr->v0 = NaNSig.v0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c new file mode 100644 index 000000000..c1e242d23 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f16UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF16UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>15; + zPtr->v64 = (uint_fast64_t) uiA<<54; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c new file mode 100644 index 000000000..b21ba6603 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f32UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF32UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>31; + zPtr->v64 = (uint_fast64_t) uiA<<41; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c new file mode 100644 index 000000000..6529d2ee5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_f64UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF64UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>63; + zPtr->v64 = uiA<<12; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c new file mode 100644 index 000000000..ea1d57a78 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80M.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by `zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ) +{ + bool isSigNaNA; + const struct extFloat80M *sPtr; + bool isSigNaNB; + uint_fast16_t uiB64; + uint64_t uiB0; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiMagA64, uiMagB64; + + isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ); + sPtr = aSPtr; + if ( ! bSPtr ) { + if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid ); + goto copy; + } + isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ); + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + uiB64 = bSPtr->signExp; + if ( isSigNaNB ) goto returnLargerUIMag; + uiB0 = bSPtr->signif; + if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB; + goto copy; + } else { + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy; + goto copyB; + } + } + uiB64 = bSPtr->signExp; + returnLargerUIMag: + uiA64 = aSPtr->signExp; + uiMagA64 = uiA64 & 0x7FFF; + uiMagB64 = uiB64 & 0x7FFF; + if ( uiMagA64 < uiMagB64 ) goto copyB; + if ( uiMagB64 < uiMagA64 ) goto copy; + uiA0 = aSPtr->signif; + uiB0 = bSPtr->signif; + if ( uiA0 < uiB0 ) goto copyB; + if ( uiB0 < uiA0 ) goto copy; + if ( uiA64 < uiB64 ) goto copy; + copyB: + sPtr = bSPtr; + copy: + zSPtr->signExp = sPtr->signExp; + zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c new file mode 100644 index 000000000..cc3f0f42c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNExtF80UI.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ) +{ + bool isSigNaNA, isSigNaNB; + uint_fast64_t uiNonsigA0, uiNonsigB0; + uint_fast16_t uiMagA64, uiMagB64; + struct uint128 uiZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 ); + isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 ); + uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerMag; + if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB; + goto returnA; + } else { + if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA; + goto returnB; + } + } + returnLargerMag: + uiMagA64 = uiA64 & 0x7FFF; + uiMagB64 = uiB64 & 0x7FFF; + if ( uiMagA64 < uiMagB64 ) goto returnB; + if ( uiMagB64 < uiMagA64 ) goto returnA; + if ( uiA0 < uiB0 ) goto returnB; + if ( uiB0 < uiA0 ) goto returnA; + if ( uiA64 < uiB64 ) goto returnA; + returnB: + uiZ.v64 = uiB64; + uiZ.v0 = uiNonsigB0; + return uiZ; + returnA: + uiZ.v64 = uiA64; + uiZ.v0 = uiNonsigA0; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128M.c new file mode 100644 index 000000000..aa903bf80 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128M.c @@ -0,0 +1,76 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by `zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr', +| and `zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ) +{ + bool isSigNaNA; + const uint32_t *ptr; + + ptr = aWPtr; + isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr ); + if ( + isSigNaNA + || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr )) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) goto copy; + } + if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr; + copy: + zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000; + zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )]; + zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )]; + zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )]; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128UI.c new file mode 100644 index 000000000..1c1c2f4a0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF128UI.c @@ -0,0 +1,81 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating `uiA64' and +| `uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating `uiB64' and `uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ) +{ + bool isSigNaNA; + struct uint128 uiZ; + + isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 ); + if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) goto returnNonsigA; + } + if ( isNaNF128UI( uiA64, uiA0 ) ) { + returnNonsigA: + uiZ.v64 = uiA64; + uiZ.v0 = uiA0; + } else { + uiZ.v64 = uiB64; + uiZ.v0 = uiB0; + } + uiZ.v64 |= UINT64_C( 0x0000800000000000 ); + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF16UI.c new file mode 100644 index 000000000..4e87ff41f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF16UI.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either `uiA' or `uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ) +{ + bool isSigNaNA; + + isSigNaNA = softfloat_isSigNaNF16UI( uiA ); + if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) return uiA | 0x0200; + } + return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF32UI.c new file mode 100644 index 000000000..e1a875525 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF32UI.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either `uiA' or `uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ) +{ + bool isSigNaNA; + + isSigNaNA = softfloat_isSigNaNF32UI( uiA ); + if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) return uiA | 0x00400000; + } + return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF64UI.c new file mode 100644 index 000000000..1af349f3e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/s_propagateNaNF64UI.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either `uiA' or `uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ) +{ + bool isSigNaNA; + + isSigNaNA = softfloat_isSigNaNF64UI( uiA ); + if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 ); + } + return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/softfloat_raiseFlags.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/softfloat_raiseFlags.c new file mode 100644 index 000000000..3115306be --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/softfloat_raiseFlags.c @@ -0,0 +1,52 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Raises the exceptions specified by `flags'. Floating-point traps can be +| defined here if desired. It is currently not possible for such a trap +| to substitute a result value. If traps are not implemented, this routine +| should be simply `softfloat_exceptionFlags |= flags;'. +*----------------------------------------------------------------------------*/ +void softfloat_raiseFlags( uint_fast8_t flags ) +{ + + softfloat_exceptionFlags |= flags; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/specialize.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/specialize.h new file mode 100644 index 000000000..5fe119a1e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086-SSE/specialize.h @@ -0,0 +1,376 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef specialize_h +#define specialize_h 1 + +#include +#include +#include "primitiveTypes.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Default value for 'softfloat_detectTininess'. +*----------------------------------------------------------------------------*/ +#define init_detectTininess softfloat_tininess_afterRounding + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 32-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui32_fromPosOverflow 0xFFFFFFFF +#define ui32_fromNegOverflow 0xFFFFFFFF +#define ui32_fromNaN 0xFFFFFFFF +#define i32_fromPosOverflow (-0x7FFFFFFF - 1) +#define i32_fromNegOverflow (-0x7FFFFFFF - 1) +#define i32_fromNaN (-0x7FFFFFFF - 1) + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 64-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define i64_fromPosOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) +#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) +#define i64_fromNaN (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + +/*---------------------------------------------------------------------------- +| "Common NaN" structure, used to transfer NaN representations from one format +| to another. +*----------------------------------------------------------------------------*/ +struct commonNaN { + bool sign; +#ifdef LITTLEENDIAN + uint64_t v0, v64; +#else + uint64_t v64, v0; +#endif +}; + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 16-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF16UI 0xFE00 + +/*---------------------------------------------------------------------------- +| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a +| 16-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 32-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF32UI 0xFFC00000 + +/*---------------------------------------------------------------------------- +| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a +| 32-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 64-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a +| 64-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF ))) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 80-bit extended floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNExtF80UI64 0xFFFF +#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 80-bit unsigned integer formed from concatenating +| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended +| floating-point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF ))) + +#ifdef SOFTFLOAT_FAST_INT64 + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of an 80-bit extended floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80UIToCommonNaN( + uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 ) +#define defaultNaNF128UI0 UINT64_C( 0 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 128-bit unsigned integer formed from concatenating +| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating- +| point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF )))) + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to +| the common NaN form, and stores the resulting common NaN at the location +| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception +| is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_f128UIToCommonNaN( + uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * ); + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ); + +#else + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is +| a NaN, converts this NaN to the common NaN form, and stores the resulting +| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling +| NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80MToCommonNaN( + const struct extFloat80M *aSPtr, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| 'zSPtr'. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ); + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by 'zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI96 0xFFFF8000 +#define defaultNaNF128UI64 0 +#define defaultNaNF128UI32 0 +#define defaultNaNF128UI0 0 + +/*---------------------------------------------------------------------------- +| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN, +| converts this NaN to the common NaN form, and stores the resulting common +| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN, +| the invalid exception is raised. Argument 'aWPtr' points to an array of +| four 32-bit elements that concatenate in the platform's normal endian order +| to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument +| 'zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ); + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by 'zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr', +| and 'zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ); + +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/extF80M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/extF80M_isSignalingNaN.c new file mode 100644 index 000000000..85ee211c2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/extF80M_isSignalingNaN.c @@ -0,0 +1,57 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool extF80M_isSignalingNaN( const extFloat80_t *aPtr ) +{ + const struct extFloat80M *aSPtr; + uint64_t uiA0; + + aSPtr = (const struct extFloat80M *) aPtr; + if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false; + uiA0 = aSPtr->signif; + return + ! (uiA0 & UINT64_C( 0x4000000000000000 )) + && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/f128M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/f128M_isSignalingNaN.c new file mode 100644 index 000000000..79a707771 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/f128M_isSignalingNaN.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool f128M_isSignalingNaN( const float128_t *aPtr ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false; + return + ((uiA96 & 0x00007FFF) != 0) + || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )]) + != 0); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80M.c new file mode 100644 index 000000000..3405b3ba4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80M.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| `zSPtr'. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ) +{ + + zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF ); + zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80UI.c new file mode 100644 index 000000000..cb7424f43 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToExtF80UI.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF; + uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128M.c new file mode 100644 index 000000000..e7ea80258 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128M.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by `zWPtr'. Argument +| `zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ) +{ + + softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr ); + zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128UI.c new file mode 100644 index 000000000..7a9423bea --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF128UI.c @@ -0,0 +1,55 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 ); + uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 ); + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF16UI.c new file mode 100644 index 000000000..d4e458a94 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF16UI.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr ) +{ + + return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF32UI.c new file mode 100644 index 000000000..ed6c2268f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF32UI.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr ) +{ + + return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF64UI.c new file mode 100644 index 000000000..1182be3c9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_commonNaNToF64UI.c @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr ) +{ + + return + (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 ) + | aPtr->v64>>12; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80MToCommonNaN.c new file mode 100644 index 000000000..00baf35f8 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80MToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is +| a NaN, converts this NaN to the common NaN form, and stores the resulting +| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling +| NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80MToCommonNaN( + const struct extFloat80M *aSPtr, struct commonNaN *zPtr ) +{ + + if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = signExtF80UI64( aSPtr->signExp ); + zPtr->v64 = aSPtr->signif<<1; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80UIToCommonNaN.c new file mode 100644 index 000000000..ab6311ef2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_extF80UIToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0' +| has the bit pattern of an 80-bit extended floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80UIToCommonNaN( + uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA64>>15; + zPtr->v64 = uiA0<<1; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128MToCommonNaN.c new file mode 100644 index 000000000..55ec25b58 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128MToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN, +| converts this NaN to the common NaN form, and stores the resulting common +| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN, +| the invalid exception is raised. Argument `aWPtr' points to an array of +| four 32-bit elements that concatenate in the platform's normal endian order +| to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr ) +{ + + if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = aWPtr[indexWordHi( 4 )]>>31; + softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128UIToCommonNaN.c new file mode 100644 index 000000000..f838f02aa --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f128UIToCommonNaN.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0' +| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to +| the common NaN form, and stores the resulting common NaN at the location +| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception +| is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_f128UIToCommonNaN( + uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ) +{ + struct uint128 NaNSig; + + if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 ); + zPtr->sign = uiA64>>63; + zPtr->v64 = NaNSig.v64; + zPtr->v0 = NaNSig.v0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f16UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f16UIToCommonNaN.c new file mode 100644 index 000000000..c1e242d23 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f16UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF16UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>15; + zPtr->v64 = (uint_fast64_t) uiA<<54; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f32UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f32UIToCommonNaN.c new file mode 100644 index 000000000..b21ba6603 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f32UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF32UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>31; + zPtr->v64 = (uint_fast64_t) uiA<<41; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f64UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f64UIToCommonNaN.c new file mode 100644 index 000000000..6529d2ee5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_f64UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF64UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>63; + zPtr->v64 = uiA<<12; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80M.c new file mode 100644 index 000000000..ea1d57a78 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80M.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by `zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ) +{ + bool isSigNaNA; + const struct extFloat80M *sPtr; + bool isSigNaNB; + uint_fast16_t uiB64; + uint64_t uiB0; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiMagA64, uiMagB64; + + isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ); + sPtr = aSPtr; + if ( ! bSPtr ) { + if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid ); + goto copy; + } + isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ); + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + uiB64 = bSPtr->signExp; + if ( isSigNaNB ) goto returnLargerUIMag; + uiB0 = bSPtr->signif; + if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB; + goto copy; + } else { + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy; + goto copyB; + } + } + uiB64 = bSPtr->signExp; + returnLargerUIMag: + uiA64 = aSPtr->signExp; + uiMagA64 = uiA64 & 0x7FFF; + uiMagB64 = uiB64 & 0x7FFF; + if ( uiMagA64 < uiMagB64 ) goto copyB; + if ( uiMagB64 < uiMagA64 ) goto copy; + uiA0 = aSPtr->signif; + uiB0 = bSPtr->signif; + if ( uiA0 < uiB0 ) goto copyB; + if ( uiB0 < uiA0 ) goto copy; + if ( uiA64 < uiB64 ) goto copy; + copyB: + sPtr = bSPtr; + copy: + zSPtr->signExp = sPtr->signExp; + zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80UI.c new file mode 100644 index 000000000..cc3f0f42c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNExtF80UI.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ) +{ + bool isSigNaNA, isSigNaNB; + uint_fast64_t uiNonsigA0, uiNonsigB0; + uint_fast16_t uiMagA64, uiMagB64; + struct uint128 uiZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 ); + isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 ); + uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerMag; + if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB; + goto returnA; + } else { + if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA; + goto returnB; + } + } + returnLargerMag: + uiMagA64 = uiA64 & 0x7FFF; + uiMagB64 = uiB64 & 0x7FFF; + if ( uiMagA64 < uiMagB64 ) goto returnB; + if ( uiMagB64 < uiMagA64 ) goto returnA; + if ( uiA0 < uiB0 ) goto returnB; + if ( uiB0 < uiA0 ) goto returnA; + if ( uiA64 < uiB64 ) goto returnA; + returnB: + uiZ.v64 = uiB64; + uiZ.v0 = uiNonsigB0; + return uiZ; + returnA: + uiZ.v64 = uiA64; + uiZ.v0 = uiNonsigA0; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128M.c new file mode 100644 index 000000000..06554fbfe --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128M.c @@ -0,0 +1,108 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by `zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr', +| and `zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ) +{ + bool isSigNaNA; + const uint32_t *ptr; + bool isSigNaNB; + uint32_t uiA96, uiB96, wordMagA, wordMagB; + + isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr ); + ptr = aWPtr; + if ( ! bWPtr ) { + if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid ); + goto copy; + } + isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr ); + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerUIMag; + if ( softfloat_isNaNF128M( bWPtr ) ) goto copyB; + goto copy; + } else { + if ( softfloat_isNaNF128M( aWPtr ) ) goto copy; + goto copyB; + } + } + returnLargerUIMag: + uiA96 = aWPtr[indexWordHi( 4 )]; + uiB96 = bWPtr[indexWordHi( 4 )]; + wordMagA = uiA96 & 0x7FFFFFFF; + wordMagB = uiB96 & 0x7FFFFFFF; + if ( wordMagA < wordMagB ) goto copyB; + if ( wordMagB < wordMagA ) goto copy; + wordMagA = aWPtr[indexWord( 4, 2 )]; + wordMagB = bWPtr[indexWord( 4, 2 )]; + if ( wordMagA < wordMagB ) goto copyB; + if ( wordMagB < wordMagA ) goto copy; + wordMagA = aWPtr[indexWord( 4, 1 )]; + wordMagB = bWPtr[indexWord( 4, 1 )]; + if ( wordMagA < wordMagB ) goto copyB; + if ( wordMagB < wordMagA ) goto copy; + wordMagA = aWPtr[indexWord( 4, 0 )]; + wordMagB = bWPtr[indexWord( 4, 0 )]; + if ( wordMagA < wordMagB ) goto copyB; + if ( wordMagB < wordMagA ) goto copy; + if ( uiA96 < uiB96 ) goto copy; + copyB: + ptr = bWPtr; + copy: + zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000; + zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )]; + zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )]; + zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )]; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128UI.c new file mode 100644 index 000000000..46b9f5f2c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF128UI.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ) +{ + bool isSigNaNA, isSigNaNB; + uint_fast64_t uiNonsigA64, uiNonsigB64, uiMagA64, uiMagB64; + struct uint128 uiZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 ); + isSigNaNB = softfloat_isSigNaNF128UI( uiB64, uiB0 ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiNonsigA64 = uiA64 | UINT64_C( 0x0000800000000000 ); + uiNonsigB64 = uiB64 | UINT64_C( 0x0000800000000000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerMag; + if ( isNaNF128UI( uiB64, uiB0 ) ) goto returnB; + goto returnA; + } else { + if ( isNaNF128UI( uiA64, uiA0 ) ) goto returnA; + goto returnB; + } + } + returnLargerMag: + uiMagA64 = uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + uiMagB64 = uiB64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( uiMagA64 < uiMagB64 ) goto returnB; + if ( uiMagB64 < uiMagA64 ) goto returnA; + if ( uiA0 < uiB0 ) goto returnB; + if ( uiB0 < uiA0 ) goto returnA; + if ( uiNonsigA64 < uiNonsigB64 ) goto returnA; + returnB: + uiZ.v64 = uiNonsigB64; + uiZ.v0 = uiB0; + return uiZ; + returnA: + uiZ.v64 = uiNonsigA64; + uiZ.v0 = uiA0; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF16UI.c new file mode 100644 index 000000000..89cc0fe97 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF16UI.c @@ -0,0 +1,84 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ) +{ + bool isSigNaNA, isSigNaNB; + uint_fast16_t uiNonsigA, uiNonsigB, uiMagA, uiMagB; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isSigNaNA = softfloat_isSigNaNF16UI( uiA ); + isSigNaNB = softfloat_isSigNaNF16UI( uiB ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiNonsigA = uiA | 0x0200; + uiNonsigB = uiB | 0x0200; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerMag; + return isNaNF16UI( uiB ) ? uiNonsigB : uiNonsigA; + } else { + return isNaNF16UI( uiA ) ? uiNonsigA : uiNonsigB; + } + } + returnLargerMag: + uiMagA = uiA & 0x7FFF; + uiMagB = uiB & 0x7FFF; + if ( uiMagA < uiMagB ) return uiNonsigB; + if ( uiMagB < uiMagA ) return uiNonsigA; + return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF32UI.c new file mode 100644 index 000000000..aeb6024ac --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF32UI.c @@ -0,0 +1,84 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ) +{ + bool isSigNaNA, isSigNaNB; + uint_fast32_t uiNonsigA, uiNonsigB, uiMagA, uiMagB; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isSigNaNA = softfloat_isSigNaNF32UI( uiA ); + isSigNaNB = softfloat_isSigNaNF32UI( uiB ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiNonsigA = uiA | 0x00400000; + uiNonsigB = uiB | 0x00400000; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerMag; + return isNaNF32UI( uiB ) ? uiNonsigB : uiNonsigA; + } else { + return isNaNF32UI( uiA ) ? uiNonsigA : uiNonsigB; + } + } + returnLargerMag: + uiMagA = uiA & 0x7FFFFFFF; + uiMagB = uiB & 0x7FFFFFFF; + if ( uiMagA < uiMagB ) return uiNonsigB; + if ( uiMagB < uiMagA ) return uiNonsigA; + return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF64UI.c new file mode 100644 index 000000000..dabad4024 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/s_propagateNaNF64UI.c @@ -0,0 +1,84 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ) +{ + bool isSigNaNA, isSigNaNB; + uint_fast64_t uiNonsigA, uiNonsigB, uiMagA, uiMagB; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isSigNaNA = softfloat_isSigNaNF64UI( uiA ); + isSigNaNB = softfloat_isSigNaNF64UI( uiB ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiNonsigA = uiA | UINT64_C( 0x0008000000000000 ); + uiNonsigB = uiB | UINT64_C( 0x0008000000000000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerMag; + return isNaNF64UI( uiB ) ? uiNonsigB : uiNonsigA; + } else { + return isNaNF64UI( uiA ) ? uiNonsigA : uiNonsigB; + } + } + returnLargerMag: + uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( uiMagA < uiMagB ) return uiNonsigB; + if ( uiMagB < uiMagA ) return uiNonsigA; + return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/softfloat_raiseFlags.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/softfloat_raiseFlags.c new file mode 100644 index 000000000..3115306be --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/softfloat_raiseFlags.c @@ -0,0 +1,52 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Raises the exceptions specified by `flags'. Floating-point traps can be +| defined here if desired. It is currently not possible for such a trap +| to substitute a result value. If traps are not implemented, this routine +| should be simply `softfloat_exceptionFlags |= flags;'. +*----------------------------------------------------------------------------*/ +void softfloat_raiseFlags( uint_fast8_t flags ) +{ + + softfloat_exceptionFlags |= flags; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/specialize.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/specialize.h new file mode 100644 index 000000000..5fe119a1e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/8086/specialize.h @@ -0,0 +1,376 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef specialize_h +#define specialize_h 1 + +#include +#include +#include "primitiveTypes.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Default value for 'softfloat_detectTininess'. +*----------------------------------------------------------------------------*/ +#define init_detectTininess softfloat_tininess_afterRounding + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 32-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui32_fromPosOverflow 0xFFFFFFFF +#define ui32_fromNegOverflow 0xFFFFFFFF +#define ui32_fromNaN 0xFFFFFFFF +#define i32_fromPosOverflow (-0x7FFFFFFF - 1) +#define i32_fromNegOverflow (-0x7FFFFFFF - 1) +#define i32_fromNaN (-0x7FFFFFFF - 1) + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 64-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define i64_fromPosOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) +#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) +#define i64_fromNaN (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + +/*---------------------------------------------------------------------------- +| "Common NaN" structure, used to transfer NaN representations from one format +| to another. +*----------------------------------------------------------------------------*/ +struct commonNaN { + bool sign; +#ifdef LITTLEENDIAN + uint64_t v0, v64; +#else + uint64_t v64, v0; +#endif +}; + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 16-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF16UI 0xFE00 + +/*---------------------------------------------------------------------------- +| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a +| 16-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 32-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF32UI 0xFFC00000 + +/*---------------------------------------------------------------------------- +| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a +| 32-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 64-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a +| 64-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF ))) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 80-bit extended floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNExtF80UI64 0xFFFF +#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 80-bit unsigned integer formed from concatenating +| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended +| floating-point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF ))) + +#ifdef SOFTFLOAT_FAST_INT64 + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of an 80-bit extended floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80UIToCommonNaN( + uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 ) +#define defaultNaNF128UI0 UINT64_C( 0 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 128-bit unsigned integer formed from concatenating +| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating- +| point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF )))) + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to +| the common NaN form, and stores the resulting common NaN at the location +| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception +| is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_f128UIToCommonNaN( + uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * ); + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ); + +#else + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is +| a NaN, converts this NaN to the common NaN form, and stores the resulting +| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling +| NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80MToCommonNaN( + const struct extFloat80M *aSPtr, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| 'zSPtr'. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ); + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by 'zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI96 0xFFFF8000 +#define defaultNaNF128UI64 0 +#define defaultNaNF128UI32 0 +#define defaultNaNF128UI0 0 + +/*---------------------------------------------------------------------------- +| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN, +| converts this NaN to the common NaN form, and stores the resulting common +| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN, +| the invalid exception is raised. Argument 'aWPtr' points to an array of +| four 32-bit elements that concatenate in the platform's normal endian order +| to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument +| 'zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ); + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by 'zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr', +| and 'zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ); + +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c new file mode 100644 index 000000000..85ee211c2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c @@ -0,0 +1,57 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool extF80M_isSignalingNaN( const extFloat80_t *aPtr ) +{ + const struct extFloat80M *aSPtr; + uint64_t uiA0; + + aSPtr = (const struct extFloat80M *) aPtr; + if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false; + uiA0 = aSPtr->signif; + return + ! (uiA0 & UINT64_C( 0x4000000000000000 )) + && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c new file mode 100644 index 000000000..79a707771 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool f128M_isSignalingNaN( const float128_t *aPtr ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false; + return + ((uiA96 & 0x00007FFF) != 0) + || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )]) + != 0); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c new file mode 100644 index 000000000..54a50dc35 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c @@ -0,0 +1,57 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "softfloat_types.h" + +#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| 'zSPtr'. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ) +{ + + zSPtr->signExp = defaultNaNExtF80UI64; + zSPtr->signif = defaultNaNExtF80UI0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c new file mode 100644 index 000000000..5b698f664 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c @@ -0,0 +1,57 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "primitiveTypes.h" + +#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ.v64 = defaultNaNExtF80UI64; + uiZ.v0 = defaultNaNExtF80UI0; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c new file mode 100644 index 000000000..b22baa816 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument +| 'zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ) +{ + + zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96; + zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64; + zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32; + zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c new file mode 100644 index 000000000..70f0cf1c6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "primitiveTypes.h" + +#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c new file mode 100644 index 000000000..7c7d5c82e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c @@ -0,0 +1,5 @@ + +/*---------------------------------------------------------------------------- +| This file intentionally contains no code. +*----------------------------------------------------------------------------*/ + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c new file mode 100644 index 000000000..1c6510c7e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c @@ -0,0 +1,74 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by 'zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ) +{ + uint_fast16_t ui64; + uint_fast64_t ui0; + + ui64 = aSPtr->signExp; + ui0 = aSPtr->signif; + if ( + softfloat_isSigNaNExtF80UI( ui64, ui0 ) + || (bSPtr + && (ui64 = bSPtr->signExp, + ui0 = bSPtr->signif, + softfloat_isSigNaNExtF80UI( ui64, ui0 ))) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zSPtr->signExp = defaultNaNExtF80UI64; + zSPtr->signif = defaultNaNExtF80UI0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c new file mode 100644 index 000000000..e1bb1555a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ) +{ + struct uint128 uiZ; + + if ( + softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) + || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + uiZ.v64 = defaultNaNExtF80UI64; + uiZ.v0 = defaultNaNExtF80UI0; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c new file mode 100644 index 000000000..9bddee955 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c @@ -0,0 +1,68 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by 'zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr', +| and 'zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ) +{ + + if ( + f128M_isSignalingNaN( (const float128_t *) aWPtr ); + || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr )) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96; + zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64; + zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32; + zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c new file mode 100644 index 000000000..57fddd158 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ) +{ + struct uint128 uiZ; + + if ( + softfloat_isSigNaNF128UI( uiA64, uiA0 ) + || softfloat_isSigNaNF128UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c new file mode 100644 index 000000000..0b08e0039 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c @@ -0,0 +1,58 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ) +{ + + if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return defaultNaNF16UI; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c new file mode 100644 index 000000000..cab740358 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c @@ -0,0 +1,58 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ) +{ + + if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return defaultNaNF32UI; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c new file mode 100644 index 000000000..83b91d3a9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c @@ -0,0 +1,58 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ) +{ + + if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return defaultNaNF64UI; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c new file mode 100644 index 000000000..61046da3c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c @@ -0,0 +1,52 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Raises the exceptions specified by 'flags'. Floating-point traps can be +| defined here if desired. It is currently not possible for such a trap +| to substitute a result value. If traps are not implemented, this routine +| should be simply 'softfloat_exceptionFlags |= flags;'. +*----------------------------------------------------------------------------*/ +void softfloat_raiseFlags( uint_fast8_t flags ) +{ + + softfloat_exceptionFlags |= flags; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h new file mode 100644 index 000000000..2c481a259 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2-defaultNaN/specialize.h @@ -0,0 +1,407 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef specialize_h +#define specialize_h 1 + +#include +#include +#include "primitiveTypes.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Default value for 'softfloat_detectTininess'. +*----------------------------------------------------------------------------*/ +#define init_detectTininess softfloat_tininess_beforeRounding + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 32-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui32_fromPosOverflow 0xFFFFFFFF +#define ui32_fromNegOverflow 0 +#define ui32_fromNaN 0 +#define i32_fromPosOverflow 0x7FFFFFFF +#define i32_fromNegOverflow (-0x7FFFFFFF - 1) +#define i32_fromNaN 0 + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 64-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define ui64_fromNegOverflow 0 +#define ui64_fromNaN 0 +#define i64_fromPosOverflow INT64_C( 0x7FFFFFFFFFFFFFFF ) +#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) +#define i64_fromNaN 0 + +/*---------------------------------------------------------------------------- +| "Common NaN" structure, used to transfer NaN representations from one format +| to another. +*----------------------------------------------------------------------------*/ +struct commonNaN { char _unused; }; + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 16-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF16UI 0x7E00 + +/*---------------------------------------------------------------------------- +| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a +| 16-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid ) + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI) + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 32-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF32UI 0x7FC00000 + +/*---------------------------------------------------------------------------- +| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a +| 32-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid ) + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI) + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 64-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a +| 64-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF ))) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid ) + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI) + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 80-bit extended floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNExtF80UI64 0x7FFF +#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 80-bit unsigned integer formed from concatenating +| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended +| floating-point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF ))) + +#ifdef SOFTFLOAT_FAST_INT64 + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of an 80-bit extended floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid ) + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI +INLINE +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + uiZ.v64 = defaultNaNExtF80UI64; + uiZ.v0 = defaultNaNExtF80UI0; + return uiZ; +} +#else +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ); +#endif + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 ) +#define defaultNaNF128UI0 UINT64_C( 0 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 128-bit unsigned integer formed from concatenating +| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating- +| point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF )))) + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to +| the common NaN form, and stores the resulting common NaN at the location +| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception +| is raised. +*----------------------------------------------------------------------------*/ +#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid ) + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +#if defined INLINE && ! defined softfloat_commonNaNToF128UI +INLINE +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + return uiZ; +} +#else +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * ); +#endif + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ); + +#else + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is +| a NaN, converts this NaN to the common NaN form, and stores the resulting +| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling +| NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid ) + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| 'zSPtr'. +*----------------------------------------------------------------------------*/ +#if defined INLINE && ! defined softfloat_commonNaNToExtF80M +INLINE +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ) +{ + zSPtr->signExp = defaultNaNExtF80UI64; + zSPtr->signif = defaultNaNExtF80UI0; +} +#else +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ); +#endif + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by 'zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI96 0x7FFF8000 +#define defaultNaNF128UI64 0 +#define defaultNaNF128UI32 0 +#define defaultNaNF128UI0 0 + +/*---------------------------------------------------------------------------- +| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN, +| converts this NaN to the common NaN form, and stores the resulting common +| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN, +| the invalid exception is raised. Argument 'aWPtr' points to an array of +| four 32-bit elements that concatenate in the platform's normal endian order +| to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid ) + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument +| 'zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +#if defined INLINE && ! defined softfloat_commonNaNToF128M +INLINE +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ) +{ + zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96; + zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64; + zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32; + zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0; +} +#else +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ); +#endif + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by 'zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr', +| and 'zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ); + +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/extF80M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/extF80M_isSignalingNaN.c new file mode 100644 index 000000000..85ee211c2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/extF80M_isSignalingNaN.c @@ -0,0 +1,57 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool extF80M_isSignalingNaN( const extFloat80_t *aPtr ) +{ + const struct extFloat80M *aSPtr; + uint64_t uiA0; + + aSPtr = (const struct extFloat80M *) aPtr; + if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false; + uiA0 = aSPtr->signif; + return + ! (uiA0 & UINT64_C( 0x4000000000000000 )) + && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/f128M_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/f128M_isSignalingNaN.c new file mode 100644 index 000000000..79a707771 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/f128M_isSignalingNaN.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool f128M_isSignalingNaN( const float128_t *aPtr ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false; + return + ((uiA96 & 0x00007FFF) != 0) + || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )]) + != 0); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80M.c new file mode 100644 index 000000000..543400bc1 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80M.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| 'zSPtr'. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ) +{ + + zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF ); + zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80UI.c new file mode 100644 index 000000000..6cf1d1191 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToExtF80UI.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF; + uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1; + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128M.c new file mode 100644 index 000000000..4e8ede07f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128M.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument +| 'zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ) +{ + + softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr ); + zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128UI.c new file mode 100644 index 000000000..f938c3f2d --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF128UI.c @@ -0,0 +1,55 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr ) +{ + struct uint128 uiZ; + + uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 ); + uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 ); + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF16UI.c new file mode 100644 index 000000000..6cd4fc192 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF16UI.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr ) +{ + + return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF32UI.c new file mode 100644 index 000000000..7b38167f0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF32UI.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr ) +{ + + return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF64UI.c new file mode 100644 index 000000000..14847029d --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_commonNaNToF64UI.c @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr ) +{ + + return + (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 ) + | aPtr->v64>>12; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c new file mode 100644 index 000000000..82216cf41 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80MToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is +| a NaN, converts this NaN to the common NaN form, and stores the resulting +| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling +| NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80MToCommonNaN( + const struct extFloat80M *aSPtr, struct commonNaN *zPtr ) +{ + + if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = signExtF80UI64( aSPtr->signExp ); + zPtr->v64 = aSPtr->signif<<1; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c new file mode 100644 index 000000000..2559fb6d2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_extF80UIToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of an 80-bit extended floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80UIToCommonNaN( + uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA64>>15; + zPtr->v64 = uiA0<<1; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c new file mode 100644 index 000000000..322d25ab1 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128MToCommonNaN.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN, +| converts this NaN to the common NaN form, and stores the resulting common +| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN, +| the invalid exception is raised. Argument 'aWPtr' points to an array of +| four 32-bit elements that concatenate in the platform's normal endian order +| to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr ) +{ + + if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = aWPtr[indexWordHi( 4 )]>>31; + softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c new file mode 100644 index 000000000..843c187a7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f128UIToCommonNaN.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to +| the common NaN form, and stores the resulting common NaN at the location +| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception +| is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_f128UIToCommonNaN( + uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ) +{ + struct uint128 NaNSig; + + if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 ); + zPtr->sign = uiA64>>63; + zPtr->v64 = NaNSig.v64; + zPtr->v0 = NaNSig.v0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c new file mode 100644 index 000000000..f5fe58770 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f16UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF16UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>15; + zPtr->v64 = (uint_fast64_t) uiA<<54; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c new file mode 100644 index 000000000..58726a357 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f32UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF32UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>31; + zPtr->v64 = (uint_fast64_t) uiA<<41; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c new file mode 100644 index 000000000..03761e433 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_f64UIToCommonNaN.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr ) +{ + + if ( softfloat_isSigNaNF64UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + zPtr->sign = uiA>>63; + zPtr->v64 = uiA<<12; + zPtr->v0 = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c new file mode 100644 index 000000000..f10ed0b62 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80M.c @@ -0,0 +1,86 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by 'zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ) +{ + const struct extFloat80M *sPtr; + bool isSigNaNA; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + sPtr = aSPtr; + isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ); + if ( + isSigNaNA + || (bSPtr + && extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr )) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) goto copyNonsig; + goto copyNonsigB; + } + uiZ64 = sPtr->signExp; + uiZ0 = sPtr->signif; + if ( isNaNExtF80UI( uiZ64, uiZ0 ) ) goto returnNonsig; + copyNonsigB: + sPtr = bSPtr; + copyNonsig: + uiZ64 = sPtr->signExp; + uiZ0 = sPtr->signif; + returnNonsig: + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0 | UINT64_C( 0xC000000000000000 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c new file mode 100644 index 000000000..bd23c2473 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNExtF80UI.c @@ -0,0 +1,83 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ) +{ + bool isSigNaNA; + struct uint128 uiZ; + + isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 ); + if ( isSigNaNA || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) goto returnNonsigA; + goto returnNonsigB; + } + if ( isNaNExtF80UI( uiA64, uiA0 ) ) { + returnNonsigA: + uiZ.v64 = uiA64; + uiZ.v0 = uiA0; + } else { + returnNonsigB: + uiZ.v64 = uiB64; + uiZ.v0 = uiB0; + } + uiZ.v0 | UINT64_C( 0xC000000000000000 ); + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c new file mode 100644 index 000000000..23e766a19 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128M.c @@ -0,0 +1,77 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by 'zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr', +| and 'zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ) +{ + const uint32_t *ptr; + bool isSigNaNA; + + ptr = aWPtr; + isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr ); + if ( + isSigNaNA + || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr )) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( ! isSigNaNA ) ptr = bWPtr; + goto copyNonsig; + } + if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr; + copyNonsig: + zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000; + zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )]; + zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )]; + zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )]; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c new file mode 100644 index 000000000..b8882d77c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF128UI.c @@ -0,0 +1,83 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ) +{ + bool isSigNaNA; + struct uint128 uiZ; + + isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 ); + if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( isSigNaNA ) goto returnNonsigA; + goto returnNonsigB; + } + if ( isNaNF128UI( uiA64, uiA0 ) ) { + returnNonsigA: + uiZ.v64 = uiA64; + uiZ.v0 = uiA0; + } else { + returnNonsigB: + uiZ.v64 = uiB64; + uiZ.v0 = uiB0; + } + uiZ.v64 |= UINT64_C( 0x0000800000000000 ); + return uiZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c new file mode 100644 index 000000000..e33332874 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF16UI.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ) +{ + bool isSigNaNA; + + isSigNaNA = softfloat_isSigNaNF16UI( uiA ); + if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return (isSigNaNA ? uiA : uiB) | 0x0200; + } + return isNaNF16UI( uiA ) ? uiA : uiB; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c new file mode 100644 index 000000000..c7508ae7c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF32UI.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ) +{ + bool isSigNaNA; + + isSigNaNA = softfloat_isSigNaNF32UI( uiA ); + if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return (isSigNaNA ? uiA : uiB) | 0x00400000; + } + return isNaNF32UI( uiA ) ? uiA : uiB; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c new file mode 100644 index 000000000..8c6776381 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/s_propagateNaNF64UI.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ) +{ + bool isSigNaNA; + + isSigNaNA = softfloat_isSigNaNF64UI( uiA ); + if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return (isSigNaNA ? uiA : uiB) | UINT64_C( 0x0008000000000000 ); + } + return isNaNF64UI( uiA ) ? uiA : uiB; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c new file mode 100644 index 000000000..61046da3c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/softfloat_raiseFlags.c @@ -0,0 +1,52 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Raises the exceptions specified by 'flags'. Floating-point traps can be +| defined here if desired. It is currently not possible for such a trap +| to substitute a result value. If traps are not implemented, this routine +| should be simply 'softfloat_exceptionFlags |= flags;'. +*----------------------------------------------------------------------------*/ +void softfloat_raiseFlags( uint_fast8_t flags ) +{ + + softfloat_exceptionFlags |= flags; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/specialize.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/specialize.h new file mode 100644 index 000000000..5321f33bc --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ARM-VFPv2/specialize.h @@ -0,0 +1,376 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef specialize_h +#define specialize_h 1 + +#include +#include +#include "primitiveTypes.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Default value for 'softfloat_detectTininess'. +*----------------------------------------------------------------------------*/ +#define init_detectTininess softfloat_tininess_beforeRounding + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 32-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui32_fromPosOverflow 0xFFFFFFFF +#define ui32_fromNegOverflow 0 +#define ui32_fromNaN 0 +#define i32_fromPosOverflow 0x7FFFFFFF +#define i32_fromNegOverflow (-0x7FFFFFFF - 1) +#define i32_fromNaN 0 + +/*---------------------------------------------------------------------------- +| The values to return on conversions to 64-bit integer formats that raise an +| invalid exception. +*----------------------------------------------------------------------------*/ +#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF ) +#define ui64_fromNegOverflow 0 +#define ui64_fromNaN 0 +#define i64_fromPosOverflow INT64_C( 0x7FFFFFFFFFFFFFFF ) +#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) +#define i64_fromNaN 0 + +/*---------------------------------------------------------------------------- +| "Common NaN" structure, used to transfer NaN representations from one format +| to another. +*----------------------------------------------------------------------------*/ +struct commonNaN { + bool sign; +#ifdef LITTLEENDIAN + uint64_t v0, v64; +#else + uint64_t v64, v0; +#endif +}; + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 16-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF16UI 0x7E00 + +/*---------------------------------------------------------------------------- +| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a +| 16-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast16_t + softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 32-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF32UI 0x7FC00000 + +/*---------------------------------------------------------------------------- +| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a +| 32-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF)) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 64-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a +| 64-bit floating-point signaling NaN. +| Note: This macro evaluates its argument more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF ))) + +/*---------------------------------------------------------------------------- +| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating- +| point values, at least one of which is a NaN, returns the bit pattern of +| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 80-bit extended floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNExtF80UI64 0x7FFF +#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 80-bit unsigned integer formed from concatenating +| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended +| floating-point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF ))) + +#ifdef SOFTFLOAT_FAST_INT64 + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of an 80-bit extended floating-point NaN, converts +| this NaN to the common NaN form, and stores the resulting common NaN at the +| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80UIToCommonNaN( + uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and returns the bit pattern of this value as an unsigned +| integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr ); + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting +| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 80-bit extended floating-point value, and assuming at least on of these +| floating-point values is a NaN, returns the bit pattern of the combined NaN +| result. If either original floating-point value is a signaling NaN, the +| invalid exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNExtF80UI( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0 + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 ) +#define defaultNaNF128UI0 UINT64_C( 0 ) + +/*---------------------------------------------------------------------------- +| Returns true when the 128-bit unsigned integer formed from concatenating +| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating- +| point signaling NaN. +| Note: This macro evaluates its arguments more than once. +*----------------------------------------------------------------------------*/ +#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF )))) + +/*---------------------------------------------------------------------------- +| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0' +| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to +| the common NaN form, and stores the resulting common NaN at the location +| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception +| is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_f128UIToCommonNaN( + uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and returns the bit pattern of this value as an unsigned integer. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * ); + +/*---------------------------------------------------------------------------- +| Interpreting the unsigned integer formed from concatenating 'uiA64' and +| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the +| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another +| 128-bit floating-point value, and assuming at least on of these floating- +| point values is a NaN, returns the bit pattern of the combined NaN result. +| If either original floating-point value is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_propagateNaNF128UI( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0 + ); + +#else + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not +| defined. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is +| a NaN, converts this NaN to the common NaN form, and stores the resulting +| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling +| NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_extF80MToCommonNaN( + const struct extFloat80M *aSPtr, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended +| floating-point NaN, and stores this NaN at the location pointed to by +| 'zSPtr'. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToExtF80M( + const struct commonNaN *aPtr, struct extFloat80M *zSPtr ); + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 80-bit extended floating-point values +| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result +| at the location pointed to by 'zSPtr'. If either original floating-point +| value is a signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ); + +/*---------------------------------------------------------------------------- +| The bit pattern for a default generated 128-bit floating-point NaN. +*----------------------------------------------------------------------------*/ +#define defaultNaNF128UI96 0x7FFF8000 +#define defaultNaNF128UI64 0 +#define defaultNaNF128UI32 0 +#define defaultNaNF128UI0 0 + +/*---------------------------------------------------------------------------- +| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN, +| converts this NaN to the common NaN form, and stores the resulting common +| NaN at the location pointed to by 'zPtr'. If the NaN is a signaling NaN, +| the invalid exception is raised. Argument 'aWPtr' points to an array of +| four 32-bit elements that concatenate in the platform's normal endian order +| to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr ); + +/*---------------------------------------------------------------------------- +| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point +| NaN, and stores this NaN at the location pointed to by 'zWPtr'. Argument +| 'zWPtr' points to an array of four 32-bit elements that concatenate in the +| platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr ); + +/*---------------------------------------------------------------------------- +| Assuming at least one of the two 128-bit floating-point values pointed to by +| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location +| pointed to by 'zWPtr'. If either original floating-point value is a +| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr', +| and 'zWPtr' points to an array of four 32-bit elements that concatenate in +| the platform's normal endian order to form a 128-bit floating-point value. +*----------------------------------------------------------------------------*/ +void + softfloat_propagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ); + +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_add.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_add.c new file mode 100644 index 000000000..02e415fcc --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_add.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + extF80M_add( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + extFloat80_t + (*magsFuncPtr)( + uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); +#endif + + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + signA = signExtF80UI64( uiA64 ); + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + signB = signExtF80UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80; + *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + +#else + +void + extF80M_add( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + softfloat_addExtF80M( + (const struct extFloat80M *) aPtr, + (const struct extFloat80M *) bPtr, + (struct extFloat80M *) zPtr, + false + ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_div.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_div.c new file mode 100644 index 000000000..4d543ce9e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_div.c @@ -0,0 +1,194 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + extF80M_div( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + *zPtr = extF80_div( *aPtr, *bPtr ); + +} + +#else + +void + extF80M_div( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + struct extFloat80M *zSPtr; + uint_fast16_t uiA64; + int32_t expA; + uint_fast16_t uiB64; + int32_t expB; + bool signZ; + uint64_t sigA, x64; + int32_t expZ; + int shiftDist; + uint32_t y[3], recip32, sigB[3]; + int ix; + uint32_t q, qs[2]; + uint_fast16_t uiZ64; + uint64_t uiZ0; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + zSPtr = (struct extFloat80M *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + expA = expExtF80UI64( uiA64 ); + uiB64 = bSPtr->signExp; + expB = expExtF80UI64( uiB64 ); + signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return; + if ( expA == 0x7FFF ) { + if ( expB == 0x7FFF ) goto invalid; + goto infinity; + } + goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sigA = aSPtr->signif; + x64 = bSPtr->signif; + if ( ! expB ) expB = 1; + if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) { + if ( ! x64 ) { + if ( ! sigA ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinite ); + goto infinity; + } + expB += softfloat_normExtF80SigM( &x64 ); + } + if ( ! expA ) expA = 1; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigA ) goto zero; + expA += softfloat_normExtF80SigM( &sigA ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA - expB + 0x3FFF; + shiftDist = 29; + if ( sigA < x64 ) { + --expZ; + shiftDist = 30; + } + softfloat_shortShiftLeft64To96M( sigA, shiftDist, y ); + recip32 = softfloat_approxRecip32_1( x64>>32 ); + sigB[indexWord( 3, 0 )] = (uint32_t) x64<<30; + x64 >>= 2; + sigB[indexWord( 3, 2 )] = x64>>32; + sigB[indexWord( 3, 1 )] = x64; + ix = 2; + for (;;) { + x64 = (uint64_t) y[indexWordHi( 3 )] * recip32; + q = (x64 + 0x80000000)>>32; + --ix; + if ( ix < 0 ) break; + softfloat_remStep96MBy32( y, 29, sigB, q, y ); + if ( y[indexWordHi( 3 )] & 0x80000000 ) { + --q; + softfloat_add96M( y, sigB, y ); + } + qs[ix] = q; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ((q + 1) & 0x3FFFFF) < 2 ) { + softfloat_remStep96MBy32( y, 29, sigB, q, y ); + if ( y[indexWordHi( 3 )] & 0x80000000 ) { + --q; + softfloat_add96M( y, sigB, y ); + } else if ( softfloat_compare96M( sigB, y ) <= 0 ) { + ++q; + softfloat_sub96M( y, sigB, y ); + } + if ( + y[indexWordLo( 3 )] || y[indexWord( 3, 1 )] || y[indexWord( 3, 2 )] + ) { + q |= 1; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + x64 = (uint64_t) q<<9; + y[indexWord( 3, 0 )] = x64; + x64 = ((uint64_t) qs[0]<<6) + (x64>>32); + y[indexWord( 3, 1 )] = x64; + y[indexWord( 3, 2 )] = (qs[1]<<3) + (x64>>32); + softfloat_roundPackMToExtF80M( + signZ, expZ, y, extF80_roundingPrecision, zSPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_invalidExtF80M( zSPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infinity: + uiZ64 = packToExtF80UI64( signZ, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ64 = packToExtF80UI64( signZ, 0 ); + uiZ0 = 0; + uiZ: + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq.c new file mode 100644 index 000000000..e17aa2435 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return extF80_eq( *aPtr, *bPtr ); + +} + +#else + +bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiB64; + uint64_t uiB0; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) + || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( uiA0 == uiB0 ) { + return (uiA64 == uiB64) || ! uiA0; + } else { + if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) { + return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr ); + } + return false; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq_signaling.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq_signaling.c new file mode 100644 index 000000000..c4a732239 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_eq_signaling.c @@ -0,0 +1,92 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return extF80_eq_signaling( *aPtr, *bPtr ); + +} + +#else + +bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiB64; + uint64_t uiB0; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( uiA0 == uiB0 ) { + return (uiA64 == uiB64) || ! uiA0; + } else { + if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) { + return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr ); + } + return false; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le.c new file mode 100644 index 000000000..e54eb9eea --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return extF80_le( *aPtr, *bPtr ); + +} + +#else + +bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiB64; + uint64_t uiB0; + bool signA, ltMags; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signExtF80UI64( uiA64 ); + if ( (uiA64 ^ uiB64) & 0x8000 ) { + /*-------------------------------------------------------------------- + | Signs are different. + *--------------------------------------------------------------------*/ + return signA || ! (uiA0 | uiB0); + } else { + /*-------------------------------------------------------------------- + | Signs are the same. + *--------------------------------------------------------------------*/ + if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) { + return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0); + } + if ( uiA64 == uiB64 ) { + if ( uiA0 == uiB0 ) return true; + ltMags = (uiA0 < uiB0); + } else { + ltMags = (uiA64 < uiB64); + } + return signA ^ ltMags; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le_quiet.c new file mode 100644 index 000000000..943f26206 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_le_quiet.c @@ -0,0 +1,112 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return extF80_le_quiet( *aPtr, *bPtr ); + +} + +#else + +bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiB64; + uint64_t uiB0; + bool signA, ltMags; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) + || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signExtF80UI64( uiA64 ); + if ( (uiA64 ^ uiB64) & 0x8000 ) { + /*-------------------------------------------------------------------- + | Signs are different. + *--------------------------------------------------------------------*/ + return signA || ! (uiA0 | uiB0); + } else { + /*-------------------------------------------------------------------- + | Signs are the same. + *--------------------------------------------------------------------*/ + if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) { + return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0); + } + if ( uiA64 == uiB64 ) { + if ( uiA0 == uiB0 ) return true; + ltMags = (uiA0 < uiB0); + } else { + ltMags = (uiA64 < uiB64); + } + return signA ^ ltMags; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt.c new file mode 100644 index 000000000..cbc562f64 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return extF80_lt( *aPtr, *bPtr ); + +} + +#else + +bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiB64; + uint64_t uiB0; + bool signA, ltMags; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signExtF80UI64( uiA64 ); + if ( (uiA64 ^ uiB64) & 0x8000 ) { + /*-------------------------------------------------------------------- + | Signs are different. + *--------------------------------------------------------------------*/ + return signA && ((uiA0 | uiB0) != 0); + } else { + /*-------------------------------------------------------------------- + | Signs are the same. + *--------------------------------------------------------------------*/ + if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) { + return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0); + } + if ( uiA64 == uiB64 ) { + if ( uiA0 == uiB0 ) return false; + ltMags = (uiA0 < uiB0); + } else { + ltMags = (uiA64 < uiB64); + } + return signA ^ ltMags; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt_quiet.c new file mode 100644 index 000000000..650586d02 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_lt_quiet.c @@ -0,0 +1,112 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return extF80_lt_quiet( *aPtr, *bPtr ); + +} + +#else + +bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint64_t uiA0; + uint_fast16_t uiB64; + uint64_t uiB0; + bool signA, ltMags; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) + || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signExtF80UI64( uiA64 ); + if ( (uiA64 ^ uiB64) & 0x8000 ) { + /*-------------------------------------------------------------------- + | Signs are different. + *--------------------------------------------------------------------*/ + return signA && ((uiA0 | uiB0) != 0); + } else { + /*-------------------------------------------------------------------- + | Signs are the same. + *--------------------------------------------------------------------*/ + if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) { + return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0); + } + if ( uiA64 == uiB64 ) { + if ( uiA0 == uiB0 ) return false; + ltMags = (uiA0 < uiB0); + } else { + ltMags = (uiA64 < uiB64); + } + return signA ^ ltMags; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_mul.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_mul.c new file mode 100644 index 000000000..281394f71 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_mul.c @@ -0,0 +1,139 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + extF80M_mul( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + *zPtr = extF80_mul( *aPtr, *bPtr ); + +} + +#else + +void + extF80M_mul( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + struct extFloat80M *zSPtr; + uint_fast16_t uiA64; + int32_t expA; + uint_fast16_t uiB64; + int32_t expB; + bool signZ; + uint_fast16_t exp, uiZ64; + uint64_t uiZ0, sigA, sigB; + int32_t expZ; + uint32_t sigProd[4], *extSigZPtr; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + zSPtr = (struct extFloat80M *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + expA = expExtF80UI64( uiA64 ); + uiB64 = bSPtr->signExp; + expB = expExtF80UI64( uiB64 ); + signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return; + if ( + (! aSPtr->signif && (expA != 0x7FFF)) + || (! bSPtr->signif && (expB != 0x7FFF)) + ) { + softfloat_invalidExtF80M( zSPtr ); + return; + } + uiZ64 = packToExtF80UI64( signZ, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) expA = 1; + sigA = aSPtr->signif; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigA ) goto zero; + expA += softfloat_normExtF80SigM( &sigA ); + } + if ( ! expB ) expB = 1; + sigB = bSPtr->signif; + if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigB ) goto zero; + expB += softfloat_normExtF80SigM( &sigB ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x3FFE; + softfloat_mul64To128M( sigA, sigB, sigProd ); + if ( sigProd[indexWordLo( 4 )] ) sigProd[indexWord( 4, 1 )] |= 1; + extSigZPtr = &sigProd[indexMultiwordHi( 4, 3 )]; + if ( sigProd[indexWordHi( 4 )] < 0x80000000 ) { + --expZ; + softfloat_add96M( extSigZPtr, extSigZPtr, extSigZPtr ); + } + softfloat_roundPackMToExtF80M( + signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ64 = packToExtF80UI64( signZ, 0 ); + uiZ0 = 0; + uiZ: + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_rem.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_rem.c new file mode 100644 index 000000000..4aff18ae9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_rem.c @@ -0,0 +1,204 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + extF80M_rem( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + *zPtr = extF80_rem( *aPtr, *bPtr ); + +} + +#else + +void + extF80M_rem( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + struct extFloat80M *zSPtr; + uint_fast16_t uiA64; + int32_t expA, expB; + uint64_t x64; + bool signRem; + uint64_t sigA; + int32_t expDiff; + uint32_t rem[3], x[3], sig32B, q, recip32, rem2[3], *remPtr, *altRemPtr; + uint32_t *newRemPtr, wordMeanRem; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + zSPtr = (struct extFloat80M *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + expA = expExtF80UI64( uiA64 ); + expB = expExtF80UI64( bSPtr->signExp ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return; + if ( expA == 0x7FFF ) goto invalid; + /*-------------------------------------------------------------------- + | If we get here, then argument b is an infinity and `expB' is 0x7FFF; + | Doubling `expB' is an easy way to ensure that `expDiff' later is + | less than -1, which will result in returning a canonicalized version + | of argument a. + *--------------------------------------------------------------------*/ + expB += expB; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) expB = 1; + x64 = bSPtr->signif; + if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) { + if ( ! x64 ) goto invalid; + expB += softfloat_normExtF80SigM( &x64 ); + } + signRem = signExtF80UI64( uiA64 ); + if ( ! expA ) expA = 1; + sigA = aSPtr->signif; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigA ) { + expA = 0; + goto copyA; + } + expA += softfloat_normExtF80SigM( &sigA ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( expDiff < -1 ) goto copyA; + rem[indexWord( 3, 2 )] = sigA>>34; + rem[indexWord( 3, 1 )] = sigA>>2; + rem[indexWord( 3, 0 )] = (uint32_t) sigA<<30; + x[indexWord( 3, 0 )] = (uint32_t) x64<<30; + sig32B = x64>>32; + x64 >>= 2; + x[indexWord( 3, 2 )] = x64>>32; + x[indexWord( 3, 1 )] = x64; + if ( expDiff < 1 ) { + if ( expDiff ) { + --expB; + softfloat_add96M( x, x, x ); + q = 0; + } else { + q = (softfloat_compare96M( x, rem ) <= 0); + if ( q ) softfloat_sub96M( rem, x, rem ); + } + } else { + recip32 = softfloat_approxRecip32_1( sig32B ); + expDiff -= 30; + for (;;) { + x64 = (uint64_t) rem[indexWordHi( 3 )] * recip32; + if ( expDiff < 0 ) break; + q = (x64 + 0x80000000)>>32; + softfloat_remStep96MBy32( rem, 29, x, q, rem ); + if ( rem[indexWordHi( 3 )] & 0x80000000 ) { + softfloat_add96M( rem, x, rem ); + } + expDiff -= 29; + } + /*-------------------------------------------------------------------- + | (`expDiff' cannot be less than -29 here.) + *--------------------------------------------------------------------*/ + q = (uint32_t) (x64>>32)>>(~expDiff & 31); + softfloat_remStep96MBy32( rem, expDiff + 30, x, q, rem ); + if ( rem[indexWordHi( 3 )] & 0x80000000 ) { + remPtr = rem; + altRemPtr = rem2; + softfloat_add96M( remPtr, x, altRemPtr ); + goto selectRem; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + remPtr = rem; + altRemPtr = rem2; + do { + ++q; + newRemPtr = altRemPtr; + softfloat_sub96M( remPtr, x, newRemPtr ); + altRemPtr = remPtr; + remPtr = newRemPtr; + } while ( ! (remPtr[indexWordHi( 3 )] & 0x80000000) ); + selectRem: + softfloat_add96M( remPtr, altRemPtr, x ); + wordMeanRem = x[indexWordHi( 3 )]; + if ( + (wordMeanRem & 0x80000000) + || (! wordMeanRem && (q & 1) && ! x[indexWord( 3, 0 )] + && ! x[indexWord( 3, 1 )]) + ) { + remPtr = altRemPtr; + } + if ( remPtr[indexWordHi( 3 )] & 0x80000000 ) { + signRem = ! signRem; + softfloat_negX96M( remPtr ); + } + softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_invalidExtF80M( zSPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + copyA: + if ( expA < 1 ) { + sigA >>= 1 - expA; + expA = 0; + } + zSPtr->signExp = packToExtF80UI64( signRem, expA ); + zSPtr->signif = sigA; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_roundToInt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_roundToInt.c new file mode 100644 index 000000000..2e8572957 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_roundToInt.c @@ -0,0 +1,176 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + extF80M_roundToInt( + const extFloat80_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + extFloat80_t *zPtr + ) +{ + + *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact ); + +} + +#else + +void + extF80M_roundToInt( + const extFloat80_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + extFloat80_t *zPtr + ) +{ + const struct extFloat80M *aSPtr; + struct extFloat80M *zSPtr; + uint_fast16_t uiA64, signUI64; + int32_t exp; + uint64_t sigA; + uint_fast16_t uiZ64; + uint64_t sigZ, lastBitMask, roundBitsMask; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + zSPtr = (struct extFloat80M *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + signUI64 = uiA64 & packToExtF80UI64( 1, 0 ); + exp = expExtF80UI64( uiA64 ); + sigA = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) { + if ( !sigA ) { + uiZ64 = signUI64; + sigZ = 0; + goto uiZ; + } + exp += softfloat_normExtF80SigM( &sigA ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp <= 0x3FFE ) { + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break; + case softfloat_round_near_maxMag: + if ( exp == 0x3FFE ) goto mag1; + break; + case softfloat_round_min: + if ( signUI64 ) goto mag1; + break; + case softfloat_round_max: + if ( !signUI64 ) goto mag1; + break; +#ifdef SOFTFLOAT_ROUND_ODD + case softfloat_round_odd: + goto mag1; +#endif + } + uiZ64 = signUI64; + sigZ = 0; + goto uiZ; + mag1: + uiZ64 = signUI64 | 0x3FFF; + sigZ = UINT64_C( 0x8000000000000000 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x403E <= exp ) { + if ( exp == 0x7FFF ) { + if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr ); + return; + } + sigZ = UINT64_C( 0x8000000000000000 ); + } else { + sigZ = sigA; + } + uiZ64 = signUI64 | exp; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = signUI64 | exp; + lastBitMask = (uint64_t) 1<<(0x403E - exp); + roundBitsMask = lastBitMask - 1; + sigZ = sigA; + if ( roundingMode == softfloat_round_near_maxMag ) { + sigZ += lastBitMask>>1; + } else if ( roundingMode == softfloat_round_near_even ) { + sigZ += lastBitMask>>1; + if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask; + } else if ( + roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max) + ) { + sigZ += roundBitsMask; + } + sigZ &= ~roundBitsMask; + if ( !sigZ ) { + ++uiZ64; + sigZ = UINT64_C( 0x8000000000000000 ); + } + if ( sigZ != sigA ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + zSPtr->signExp = uiZ64; + zSPtr->signif = sigZ; + return; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sqrt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sqrt.c new file mode 100644 index 000000000..7ee91e0e5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sqrt.c @@ -0,0 +1,180 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr ) +{ + + *zPtr = extF80_sqrt( *aPtr ); + +} + +#else + +void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr ) +{ + const struct extFloat80M *aSPtr; + struct extFloat80M *zSPtr; + uint_fast16_t uiA64, signUI64; + int32_t expA; + uint64_t rem64; + int32_t expZ; + uint32_t rem96[3], sig32A, recipSqrt32, sig32Z, q; + uint64_t sig64Z, x64; + uint32_t rem32, term[4], rem[4], extSigZ[3]; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + zSPtr = (struct extFloat80M *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + signUI64 = uiA64 & packToExtF80UI64( 1, 0 ); + expA = expExtF80UI64( uiA64 ); + rem64 = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( rem64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr ); + return; + } + if ( signUI64 ) goto invalid; + rem64 = UINT64_C( 0x8000000000000000 ); + goto copyA; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) expA = 1; + if ( ! (rem64 & UINT64_C( 0x8000000000000000 )) ) { + if ( ! rem64 ) { + uiA64 = signUI64; + goto copyA; + } + expA += softfloat_normExtF80SigM( &rem64 ); + } + if ( signUI64 ) goto invalid; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = ((expA - 0x3FFF)>>1) + 0x3FFF; + expA &= 1; + softfloat_shortShiftLeft64To96M( rem64, 30 - expA, rem96 ); + sig32A = rem64>>32; + recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A ); + sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32; + if ( expA ) sig32Z >>= 1; + rem64 = + ((uint64_t) rem96[indexWord( 3, 2 )]<<32 | rem96[indexWord( 3, 1 )]) + - (uint64_t) sig32Z * sig32Z; + rem96[indexWord( 3, 2 )] = rem64>>32; + rem96[indexWord( 3, 1 )] = rem64; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32; + sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3); + term[indexWord( 3, 2 )] = 0; + /*------------------------------------------------------------------------ + | (Repeating this loop is a rare occurrence.) + *------------------------------------------------------------------------*/ + for (;;) { + x64 = ((uint64_t) sig32Z<<32) + sig64Z; + term[indexWord( 3, 1 )] = x64>>32; + term[indexWord( 3, 0 )] = x64; + softfloat_remStep96MBy32( + rem96, 29, term, q, &rem[indexMultiwordHi( 4, 3 )] ); + rem32 = rem[indexWord( 4, 3 )]; + if ( ! (rem32 & 0x80000000) ) break; + --q; + sig64Z -= 1<<3; + } + rem64 = (uint64_t) rem32<<32 | rem[indexWord( 4, 2 )]; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2; + if ( rem64>>34 ) q += recipSqrt32; + x64 = (uint64_t) q<<7; + extSigZ[indexWord( 3, 0 )] = x64; + x64 = (sig64Z<<1) + (x64>>32); + extSigZ[indexWord( 3, 2 )] = x64>>32; + extSigZ[indexWord( 3, 1 )] = x64; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (q & 0xFFFFFF) <= 2 ) { + q &= ~(uint32_t) 0xFFFF; + extSigZ[indexWordLo( 3 )] = q<<7; + x64 = sig64Z + (q>>27); + term[indexWord( 4, 3 )] = 0; + term[indexWord( 4, 2 )] = x64>>32; + term[indexWord( 4, 1 )] = x64; + term[indexWord( 4, 0 )] = q<<5; + rem[indexWord( 4, 0 )] = 0; + softfloat_remStep128MBy32( rem, 28, term, q, rem ); + q = rem[indexWordHi( 4 )]; + if ( q & 0x80000000 ) { + softfloat_sub1X96M( extSigZ ); + } else { + if ( q || rem[indexWord( 4, 1 )] || rem[indexWord( 4, 2 )] ) { + extSigZ[indexWordLo( 3 )] |= 1; + } + } + } + softfloat_roundPackMToExtF80M( + 0, expZ, extSigZ, extF80_roundingPrecision, zSPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_invalidExtF80M( zSPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + copyA: + zSPtr->signExp = uiA64; + zSPtr->signif = rem64; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sub.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sub.c new file mode 100644 index 000000000..5d1895c7a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_sub.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + extF80M_sub( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + const struct extFloat80M *aSPtr, *bSPtr; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + extFloat80_t + (*magsFuncPtr)( + uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); +#endif + + aSPtr = (const struct extFloat80M *) aPtr; + bSPtr = (const struct extFloat80M *) bPtr; + uiA64 = aSPtr->signExp; + uiA0 = aSPtr->signif; + signA = signExtF80UI64( uiA64 ); + uiB64 = bSPtr->signExp; + uiB0 = bSPtr->signif; + signB = signExtF80UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80; + *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + +#else + +void + extF80M_sub( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + softfloat_addExtF80M( + (const struct extFloat80M *) aPtr, + (const struct extFloat80M *) bPtr, + (struct extFloat80M *) zPtr, + true + ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f128M.c new file mode 100644 index 000000000..da81e8d6b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f128M.c @@ -0,0 +1,125 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr ) +{ + + *zPtr = extF80_to_f128( *aPtr ); + +} + +#else + +void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr ) +{ + const struct extFloat80M *aSPtr; + uint32_t *zWPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + struct commonNaN commonNaN; + uint32_t uiZ96; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zWPtr[indexWord( 4, 0 )] = 0; + if ( exp == 0x7FFF ) { + if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_extF80MToCommonNaN( aSPtr, &commonNaN ); + softfloat_commonNaNToF128M( &commonNaN, zWPtr ); + return; + } + uiZ96 = packToF128UI96( sign, 0x7FFF, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) --exp; + if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sig ) { + uiZ96 = packToF128UI96( sign, 0, 0 ); + goto uiZ; + } + exp += softfloat_normExtF80SigM( &sig ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zWPtr[indexWord( 4, 1 )] = (uint32_t) sig<<17; + sig >>= 15; + zWPtr[indexWord( 4, 2 )] = sig; + if ( exp < 0 ) { + zWPtr[indexWordHi( 4 )] = sig>>32; + softfloat_shiftRight96M( + &zWPtr[indexMultiwordHi( 4, 3 )], + -exp, + &zWPtr[indexMultiwordHi( 4, 3 )] + ); + exp = 0; + sig = (uint64_t) zWPtr[indexWordHi( 4 )]<<32; + } + zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp, sig>>32 ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f16.c new file mode 100644 index 000000000..5ae38d0c4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f16.c @@ -0,0 +1,112 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +float16_t extF80M_to_f16( const extFloat80_t *aPtr ) +{ + + return extF80_to_f16( *aPtr ); + +} + +#else + +float16_t extF80M_to_f16( const extFloat80_t *aPtr ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + struct commonNaN commonNaN; + uint16_t uiZ, sig16; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_extF80MToCommonNaN( aSPtr, &commonNaN ); + uiZ = softfloat_commonNaNToF16UI( &commonNaN ); + } else { + uiZ = packToF16UI( sign, 0x1F, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sig ) { + uiZ = packToF16UI( sign, 0, 0 ); + goto uiZ; + } + exp += softfloat_normExtF80SigM( &sig ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig16 = softfloat_shortShiftRightJam64( sig, 49 ); + exp -= 0x3FF1; + if ( sizeof (int_fast16_t) < sizeof (int32_t) ) { + if ( exp < -0x40 ) exp = -0x40; + } + return softfloat_roundPackToF16( sign, exp, sig16 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f32.c new file mode 100644 index 000000000..47cf224dc --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f32.c @@ -0,0 +1,112 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +float32_t extF80M_to_f32( const extFloat80_t *aPtr ) +{ + + return extF80_to_f32( *aPtr ); + +} + +#else + +float32_t extF80M_to_f32( const extFloat80_t *aPtr ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + struct commonNaN commonNaN; + uint32_t uiZ, sig32; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_extF80MToCommonNaN( aSPtr, &commonNaN ); + uiZ = softfloat_commonNaNToF32UI( &commonNaN ); + } else { + uiZ = packToF32UI( sign, 0xFF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sig ) { + uiZ = packToF32UI( sign, 0, 0 ); + goto uiZ; + } + exp += softfloat_normExtF80SigM( &sig ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig32 = softfloat_shortShiftRightJam64( sig, 33 ); + exp -= 0x3F81; + if ( sizeof (int_fast16_t) < sizeof (int32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return softfloat_roundPackToF32( sign, exp, sig32 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f64.c new file mode 100644 index 000000000..5f8f4aa29 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_f64.c @@ -0,0 +1,112 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +float64_t extF80M_to_f64( const extFloat80_t *aPtr ) +{ + + return extF80_to_f64( *aPtr ); + +} + +#else + +float64_t extF80M_to_f64( const extFloat80_t *aPtr ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + struct commonNaN commonNaN; + uint64_t uiZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_extF80MToCommonNaN( aSPtr, &commonNaN ); + uiZ = softfloat_commonNaNToF64UI( &commonNaN ); + } else { + uiZ = packToF64UI( sign, 0x7FF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sig ) { + uiZ = packToF64UI( sign, 0, 0 ); + goto uiZ; + } + exp += softfloat_normExtF80SigM( &sig ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = softfloat_shortShiftRightJam64( sig, 1 ); + exp -= 0x3C01; + if ( sizeof (int_fast16_t) < sizeof (int32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return softfloat_roundPackToF64( sign, exp, sig ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32.c new file mode 100644 index 000000000..06394e341 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast32_t + extF80M_to_i32( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return extF80_to_i32( *aPtr, roundingMode, exact ); + +} + +#else + +int_fast32_t + extF80M_to_i32( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x4032 - exp; + if ( shiftDist <= 0 ) { + if ( sig>>32 ) goto invalid; + if ( -32 < shiftDist ) { + sig <<= -shiftDist; + } else { + if ( (uint32_t) sig ) goto invalid; + } + } else { + sig = softfloat_shiftRightJam64( sig, shiftDist ); + } + return softfloat_roundToI32( sign, sig, roundingMode, exact ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN + : sign ? i32_fromNegOverflow : i32_fromPosOverflow; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32_r_minMag.c new file mode 100644 index 000000000..5f5cf599d --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i32_r_minMag.c @@ -0,0 +1,120 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + + return extF80_to_i32_r_minMag( *aPtr, exact ); + +} + +#else + +int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + bool sign, raiseInexact; + int32_t z; + uint64_t shiftedSig; + uint32_t absZ; + union { uint32_t ui; int32_t i; } u; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! sig && (exp != 0x7FFF) ) return 0; + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + raiseInexact = exact; + z = 0; + } else { + sign = signExtF80UI64( uiA64 ); + raiseInexact = false; + if ( shiftDist < 0 ) { + if ( sig>>32 || (shiftDist <= -31) ) goto invalid; + shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist; + if ( shiftedSig>>32 ) goto invalid; + absZ = shiftedSig; + } else { + shiftedSig = sig; + if ( shiftDist ) shiftedSig >>= shiftDist; + if ( shiftedSig>>32 ) goto invalid; + absZ = shiftedSig; + if ( exact && shiftDist ) { + raiseInexact = ((uint64_t) absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast64_t + extF80M_to_i64( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return extF80_to_i64( *aPtr, roundingMode, exact ); + +} + +#else + +int_fast64_t + extF80M_to_i64( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + uint32_t extSig[3]; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( shiftDist < 0 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + extSig[indexWord( 3, 2 )] = sig>>32; + extSig[indexWord( 3, 1 )] = sig; + extSig[indexWord( 3, 0 )] = 0; + if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig ); + return softfloat_roundMToI64( sign, extSig, roundingMode, exact ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i64_r_minMag.c new file mode 100644 index 000000000..ec9b92844 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_i64_r_minMag.c @@ -0,0 +1,115 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + + return extF80_to_i64_r_minMag( *aPtr, exact ); + +} + +#else + +int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + bool sign, raiseInexact; + int64_t z; + uint64_t absZ; + union { uint64_t ui; int64_t i; } u; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! sig && (exp != 0x7FFF) ) return 0; + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + raiseInexact = exact; + z = 0; + } else { + sign = signExtF80UI64( uiA64 ); + raiseInexact = false; + if ( shiftDist < 0 ) { + if ( shiftDist <= -63 ) goto invalid; + shiftDist = -shiftDist; + absZ = sig<>shiftDist != sig ) goto invalid; + } else { + absZ = sig; + if ( shiftDist ) absZ >>= shiftDist; + if ( exact && shiftDist ) raiseInexact = (absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast32_t + extF80M_to_ui32( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return extF80_to_ui32( *aPtr, roundingMode, exact ); + +} + +#else + +uint_fast32_t + extF80M_to_ui32( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x4032 - exp; + if ( shiftDist <= 0 ) { + if ( sig>>32 ) goto invalid; + if ( -32 < shiftDist ) { + sig <<= -shiftDist; + } else { + if ( (uint32_t) sig ) goto invalid; + } + } else { + sig = softfloat_shiftRightJam64( sig, shiftDist ); + } + return softfloat_roundToUI32( sign, sig, roundingMode, exact ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui32_r_minMag.c new file mode 100644 index 000000000..e28b08d70 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui32_r_minMag.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + + return extF80_to_ui32_r_minMag( *aPtr, exact ); + +} + +#else + +uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + bool sign; + uint64_t shiftedSig; + uint32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! sig && (exp != 0x7FFF) ) return 0; + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signExtF80UI64( uiA64 ); + if ( shiftDist < 0 ) { + if ( sign || sig>>32 || (shiftDist <= -31) ) goto invalid; + shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist; + if ( shiftedSig>>32 ) goto invalid; + z = shiftedSig; + } else { + shiftedSig = sig; + if ( shiftDist ) shiftedSig >>= shiftDist; + if ( shiftedSig>>32 ) goto invalid; + z = shiftedSig; + if ( sign && z ) goto invalid; + if ( exact && shiftDist && ((uint64_t) z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast64_t + extF80M_to_ui64( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return extF80_to_ui64( *aPtr, roundingMode, exact ); + +} + +#else + +uint_fast64_t + extF80M_to_ui64( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + bool sign; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + uint32_t extSig[3]; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( shiftDist < 0 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + extSig[indexWord( 3, 2 )] = sig>>32; + extSig[indexWord( 3, 1 )] = sig; + extSig[indexWord( 3, 0 )] = 0; + if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig ); + return softfloat_roundMToUI64( sign, extSig, roundingMode, exact ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui64_r_minMag.c new file mode 100644 index 000000000..87d80897b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80M_to_ui64_r_minMag.c @@ -0,0 +1,108 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + + return extF80_to_ui64_r_minMag( *aPtr, exact ); + +} + +#else + +uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + int32_t exp; + uint64_t sig; + int32_t shiftDist; + bool sign; + uint64_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aSPtr = (const struct extFloat80M *) aPtr; + uiA64 = aSPtr->signExp; + exp = expExtF80UI64( uiA64 ); + sig = aSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! sig && (exp != 0x7FFF) ) return 0; + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signExtF80UI64( uiA64 ); + if ( shiftDist < 0 ) { + if ( sign || (shiftDist <= -63) ) goto invalid; + shiftDist = -shiftDist; + z = sig<>shiftDist != sig ) goto invalid; + } else { + z = sig; + if ( shiftDist ) z >>= shiftDist; + if ( sign && z ) goto invalid; + if ( exact && shiftDist && (z< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + extFloat80_t + (*magsFuncPtr)( + uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); +#endif + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + signA = signExtF80UI64( uiA64 ); + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + signB = signExtF80UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80; + return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_div.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_div.c new file mode 100644 index 000000000..28dfb13de --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_div.c @@ -0,0 +1,203 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + int_fast32_t expA; + uint_fast64_t sigA; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signB; + int_fast32_t expB; + uint_fast64_t sigB; + bool signZ; + struct exp32_sig64 normExpSig; + int_fast32_t expZ; + struct uint128 rem; + uint_fast32_t recip32; + uint_fast64_t sigZ; + int ix; + uint_fast64_t q64; + uint_fast32_t q; + struct uint128 term; + uint_fast64_t sigZExtra; + struct uint128 uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + signA = signExtF80UI64( uiA64 ); + expA = expExtF80UI64( uiA64 ); + sigA = uiA0; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + signB = signExtF80UI64( uiB64 ); + expB = expExtF80UI64( uiB64 ); + sigB = uiB0; + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + if ( expB == 0x7FFF ) { + if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + goto invalid; + } + goto infinity; + } + if ( expB == 0x7FFF ) { + if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) expB = 1; + if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigB ) { + if ( ! sigA ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinite ); + goto infinity; + } + normExpSig = softfloat_normSubnormalExtF80Sig( sigB ); + expB += normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) expA = 1; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalExtF80Sig( sigA ); + expA += normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA - expB + 0x3FFF; + if ( sigA < sigB ) { + --expZ; + rem = softfloat_shortShiftLeft128( 0, sigA, 32 ); + } else { + rem = softfloat_shortShiftLeft128( 0, sigA, 31 ); + } + recip32 = softfloat_approxRecip32_1( sigB>>32 ); + sigZ = 0; + ix = 2; + for (;;) { + q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32; + q = (q64 + 0x80000000)>>32; + --ix; + if ( ix < 0 ) break; + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + term = softfloat_mul64ByShifted32To128( sigB, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + --q; + rem = softfloat_add128( rem.v64, rem.v0, sigB>>32, sigB<<32 ); + } + sigZ = (sigZ<<29) + q; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ((q + 1) & 0x3FFFFF) < 2 ) { + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + term = softfloat_mul64ByShifted32To128( sigB, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + term = softfloat_shortShiftLeft128( 0, sigB, 32 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + --q; + rem = softfloat_add128( rem.v64, rem.v0, term.v64, term.v0 ); + } else if ( softfloat_le128( term.v64, term.v0, rem.v64, rem.v0 ) ) { + ++q; + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + } + if ( rem.v64 | rem.v0 ) q |= 1; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sigZ = (sigZ<<6) + (q>>23); + sigZExtra = (uint64_t) ((uint_fast64_t) q<<41); + return + softfloat_roundPackToExtF80( + signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ64 = defaultNaNExtF80UI64; + uiZ0 = defaultNaNExtF80UI0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infinity: + uiZ64 = packToExtF80UI64( signZ, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ64 = packToExtF80UI64( signZ, 0 ); + uiZ0 = 0; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq.c new file mode 100644 index 000000000..efcbc3714 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool extF80_eq( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) + || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + return + (uiA0 == uiB0) + && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF))); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq_signaling.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq_signaling.c new file mode 100644 index 000000000..193b191e6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_eq_signaling.c @@ -0,0 +1,67 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + return + (uiA0 == uiB0) + && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF))); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_isSignalingNaN.c new file mode 100644 index 000000000..33d2abd7e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_isSignalingNaN.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool extF80_isSignalingNaN( extFloat80_t a ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + + uA.f = a; + return softfloat_isSigNaNExtF80UI( uA.s.signExp, uA.s.signif ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le.c new file mode 100644 index 000000000..4e23c5142 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool extF80_le( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signExtF80UI64( uiA64 ); + signB = signExtF80UI64( uiB64 ); + return + (signA != signB) + ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0) + : ((uiA64 == uiB64) && (uiA0 == uiB0)) + || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le_quiet.c new file mode 100644 index 000000000..9839e47f9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_le_quiet.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool extF80_le_quiet( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) + || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signExtF80UI64( uiA64 ); + signB = signExtF80UI64( uiB64 ); + return + (signA != signB) + ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0) + : ((uiA64 == uiB64) && (uiA0 == uiB0)) + || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt.c new file mode 100644 index 000000000..a4ac69fa6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool extF80_lt( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signExtF80UI64( uiA64 ); + signB = signExtF80UI64( uiB64 ); + return + (signA != signB) + ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0) + : ((uiA64 != uiB64) || (uiA0 != uiB0)) + && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt_quiet.c new file mode 100644 index 000000000..00f4d4768 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_lt_quiet.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) + || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signExtF80UI64( uiA64 ); + signB = signExtF80UI64( uiB64 ); + return + (signA != signB) + ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0) + : ((uiA64 != uiB64) || (uiA0 != uiB0)) + && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_mul.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_mul.c new file mode 100644 index 000000000..39ce4012c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_mul.c @@ -0,0 +1,158 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + int_fast32_t expA; + uint_fast64_t sigA; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signB; + int_fast32_t expB; + uint_fast64_t sigB; + bool signZ; + uint_fast64_t magBits; + struct exp32_sig64 normExpSig; + int_fast32_t expZ; + struct uint128 sig128Z, uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + signA = signExtF80UI64( uiA64 ); + expA = expExtF80UI64( uiA64 ); + sigA = uiA0; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + signB = signExtF80UI64( uiB64 ); + expB = expExtF80UI64( uiB64 ); + sigB = uiB0; + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( + (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ))) + ) { + goto propagateNaN; + } + magBits = expB | sigB; + goto infArg; + } + if ( expB == 0x7FFF ) { + if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + magBits = expA | sigA; + goto infArg; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) expA = 1; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalExtF80Sig( sigA ); + expA += normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) expB = 1; + if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigB ) goto zero; + normExpSig = softfloat_normSubnormalExtF80Sig( sigB ); + expB += normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x3FFE; + sig128Z = softfloat_mul64To128( sigA, sigB ); + if ( sig128Z.v64 < UINT64_C( 0x8000000000000000 ) ) { + --expZ; + sig128Z = + softfloat_add128( + sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 ); + } + return + softfloat_roundPackToExtF80( + signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infArg: + if ( ! magBits ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ64 = defaultNaNExtF80UI64; + uiZ0 = defaultNaNExtF80UI0; + } else { + uiZ64 = packToExtF80UI64( signZ, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + } + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ64 = packToExtF80UI64( signZ, 0 ); + uiZ0 = 0; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_rem.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_rem.c new file mode 100644 index 000000000..5ad977526 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_rem.c @@ -0,0 +1,225 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + int_fast32_t expA; + uint_fast64_t sigA; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + int_fast32_t expB; + uint_fast64_t sigB; + struct exp32_sig64 normExpSig; + int_fast32_t expDiff; + struct uint128 rem, shiftedSigB; + uint_fast32_t q, recip32; + uint_fast64_t q64; + struct uint128 term, altRem, meanRem; + bool signRem; + struct uint128 uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + signA = signExtF80UI64( uiA64 ); + expA = expExtF80UI64( uiA64 ); + sigA = uiA0; + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + expB = expExtF80UI64( uiB64 ); + sigB = uiB0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( + (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ))) + ) { + goto propagateNaN; + } + goto invalid; + } + if ( expB == 0x7FFF ) { + if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + /*-------------------------------------------------------------------- + | Argument b is an infinity. Doubling `expB' is an easy way to ensure + | that `expDiff' later is less than -1, which will result in returning + | a canonicalized version of argument a. + *--------------------------------------------------------------------*/ + expB += expB; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) expB = 1; + if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigB ) goto invalid; + normExpSig = softfloat_normSubnormalExtF80Sig( sigB ); + expB += normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) expA = 1; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigA ) { + expA = 0; + goto copyA; + } + normExpSig = softfloat_normSubnormalExtF80Sig( sigA ); + expA += normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( expDiff < -1 ) goto copyA; + rem = softfloat_shortShiftLeft128( 0, sigA, 32 ); + shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 32 ); + if ( expDiff < 1 ) { + if ( expDiff ) { + --expB; + shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 33 ); + q = 0; + } else { + q = (sigB <= sigA); + if ( q ) { + rem = + softfloat_sub128( + rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 ); + } + } + } else { + recip32 = softfloat_approxRecip32_1( sigB>>32 ); + expDiff -= 30; + for (;;) { + q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32; + if ( expDiff < 0 ) break; + q = (q64 + 0x80000000)>>32; + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + term = softfloat_mul64ByShifted32To128( sigB, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + rem = + softfloat_add128( + rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 ); + } + expDiff -= 29; + } + /*-------------------------------------------------------------------- + | (`expDiff' cannot be less than -29 here.) + *--------------------------------------------------------------------*/ + q = (uint32_t) (q64>>32)>>(~expDiff & 31); + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, expDiff + 30 ); + term = softfloat_mul64ByShifted32To128( sigB, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + altRem = + softfloat_add128( + rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 ); + goto selectRem; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + do { + altRem = rem; + ++q; + rem = + softfloat_sub128( + rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 ); + } while ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ); + selectRem: + meanRem = softfloat_add128( rem.v64, rem.v0, altRem.v64, altRem.v0 ); + if ( + (meanRem.v64 & UINT64_C( 0x8000000000000000 )) + || (! (meanRem.v64 | meanRem.v0) && (q & 1)) + ) { + rem = altRem; + } + signRem = signA; + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + signRem = ! signRem; + rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 ); + } + return + softfloat_normRoundPackToExtF80( + signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ64 = defaultNaNExtF80UI64; + uiZ0 = defaultNaNExtF80UI0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + copyA: + if ( expA < 1 ) { + sigA >>= 1 - expA; + expA = 0; + } + uiZ64 = packToExtF80UI64( signA, expA ); + uiZ0 = sigA; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_roundToInt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_roundToInt.c new file mode 100644 index 000000000..6c12d84c9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_roundToInt.c @@ -0,0 +1,154 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t + extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64, signUI64; + int_fast32_t exp; + uint_fast64_t sigA; + uint_fast16_t uiZ64; + uint_fast64_t sigZ; + struct exp32_sig64 normExpSig; + struct uint128 uiZ; + uint_fast64_t lastBitMask, roundBitsMask; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + signUI64 = uiA64 & packToExtF80UI64( 1, 0 ); + exp = expExtF80UI64( uiA64 ); + sigA = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) { + if ( !sigA ) { + uiZ64 = signUI64; + sigZ = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalExtF80Sig( sigA ); + exp += normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x403E <= exp ) { + if ( exp == 0x7FFF ) { + if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 ); + uiZ64 = uiZ.v64; + sigZ = uiZ.v0; + goto uiZ; + } + sigZ = UINT64_C( 0x8000000000000000 ); + } else { + sigZ = sigA; + } + uiZ64 = signUI64 | exp; + goto uiZ; + } + if ( exp <= 0x3FFE ) { + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break; + case softfloat_round_near_maxMag: + if ( exp == 0x3FFE ) goto mag1; + break; + case softfloat_round_min: + if ( signUI64 ) goto mag1; + break; + case softfloat_round_max: + if ( !signUI64 ) goto mag1; + break; +#ifdef SOFTFLOAT_ROUND_ODD + case softfloat_round_odd: + goto mag1; +#endif + } + uiZ64 = signUI64; + sigZ = 0; + goto uiZ; + mag1: + uiZ64 = signUI64 | 0x3FFF; + sigZ = UINT64_C( 0x8000000000000000 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = signUI64 | exp; + lastBitMask = (uint_fast64_t) 1<<(0x403E - exp); + roundBitsMask = lastBitMask - 1; + sigZ = sigA; + if ( roundingMode == softfloat_round_near_maxMag ) { + sigZ += lastBitMask>>1; + } else if ( roundingMode == softfloat_round_near_even ) { + sigZ += lastBitMask>>1; + if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask; + } else if ( + roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max) + ) { + sigZ += roundBitsMask; + } + sigZ &= ~roundBitsMask; + if ( !sigZ ) { + ++uiZ64; + sigZ = UINT64_C( 0x8000000000000000 ); + } + if ( sigZ != sigA ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = sigZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sqrt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sqrt.c new file mode 100644 index 000000000..af8c496e1 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sqrt.c @@ -0,0 +1,176 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t extF80_sqrt( extFloat80_t a ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + int_fast32_t expA; + uint_fast64_t sigA; + struct uint128 uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + struct exp32_sig64 normExpSig; + int_fast32_t expZ; + uint_fast32_t sig32A, recipSqrt32, sig32Z; + struct uint128 rem; + uint_fast64_t q, x64, sigZ; + struct uint128 y, term; + uint_fast64_t sigZExtra; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + signA = signExtF80UI64( uiA64 ); + expA = expExtF80UI64( uiA64 ); + sigA = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + goto uiZ; + } + if ( ! signA ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signA ) { + if ( ! sigA ) goto zero; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) expA = 1; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalExtF80Sig( sigA ); + expA += normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + | (`sig32Z' is guaranteed to be a lower bound on the square root of + | `sig32A', which makes `sig32Z' also a lower bound on the square root of + | `sigA'.) + *------------------------------------------------------------------------*/ + expZ = ((expA - 0x3FFF)>>1) + 0x3FFF; + expA &= 1; + sig32A = sigA>>32; + recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A ); + sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32; + if ( expA ) { + sig32Z >>= 1; + rem = softfloat_shortShiftLeft128( 0, sigA, 61 ); + } else { + rem = softfloat_shortShiftLeft128( 0, sigA, 62 ); + } + rem.v64 -= (uint_fast64_t) sig32Z * sig32Z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = ((uint32_t) (rem.v64>>2) * (uint_fast64_t) recipSqrt32)>>32; + x64 = (uint_fast64_t) sig32Z<<32; + sigZ = x64 + (q<<3); + y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + /*------------------------------------------------------------------------ + | (Repeating this loop is a rare occurrence.) + *------------------------------------------------------------------------*/ + for (;;) { + term = softfloat_mul64ByShifted32To128( x64 + sigZ, q ); + rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 ); + if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break; + --q; + sigZ -= 1<<3; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = (((rem.v64>>2) * recipSqrt32)>>32) + 2; + x64 = sigZ; + sigZ = (sigZ<<1) + (q>>25); + sigZExtra = (uint64_t) (q<<39); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (q & 0xFFFFFF) <= 2 ) { + q &= ~(uint_fast64_t) 0xFFFF; + sigZExtra = (uint64_t) (q<<39); + term = softfloat_mul64ByShifted32To128( x64 + (q>>27), q ); + x64 = (uint32_t) (q<<5) * (uint_fast64_t) (uint32_t) q; + term = softfloat_add128( term.v64, term.v0, 0, x64 ); + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 28 ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + if ( ! sigZExtra ) --sigZ; + --sigZExtra; + } else { + if ( rem.v64 | rem.v0 ) sigZExtra |= 1; + } + } + return + softfloat_roundPackToExtF80( + 0, expZ, sigZ, sigZExtra, extF80_roundingPrecision ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ64 = defaultNaNExtF80UI64; + uiZ0 = defaultNaNExtF80UI0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ64 = packToExtF80UI64( signA, 0 ); + uiZ0 = 0; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sub.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sub.c new file mode 100644 index 000000000..770c7563a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_sub.c @@ -0,0 +1,80 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool signA; + union { struct extFloat80M s; extFloat80_t f; } uB; + uint_fast16_t uiB64; + uint_fast64_t uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + extFloat80_t + (*magsFuncPtr)( + uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); +#endif + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + signA = signExtF80UI64( uiA64 ); + uB.f = b; + uiB64 = uB.s.signExp; + uiB0 = uB.s.signif; + signB = signExtF80UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80; + return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f128.c new file mode 100644 index 000000000..4de90ae31 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f128.c @@ -0,0 +1,75 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t extF80_to_f128( extFloat80_t a ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + uint_fast16_t exp; + uint_fast64_t frac; + struct commonNaN commonNaN; + struct uint128 uiZ; + bool sign; + struct uint128 frac128; + union ui128_f128 uZ; + + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + exp = expExtF80UI64( uiA64 ); + frac = uiA0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( (exp == 0x7FFF) && frac ) { + softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToF128UI( &commonNaN ); + } else { + sign = signExtF80UI64( uiA64 ); + frac128 = softfloat_shortShiftLeft128( 0, frac, 49 ); + uiZ.v64 = packToF128UI64( sign, exp, frac128.v64 ); + uiZ.v0 = frac128.v0; + } + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f16.c new file mode 100644 index 000000000..5919403fb --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f16.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t extF80_to_f16( extFloat80_t a ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig; + struct commonNaN commonNaN; + uint_fast16_t uiZ, sig16; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToF16UI( &commonNaN ); + } else { + uiZ = packToF16UI( sign, 0x1F, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig16 = softfloat_shortShiftRightJam64( sig, 49 ); + if ( ! (exp | sig16) ) { + uiZ = packToF16UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3FF1; + if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) { + if ( exp < -0x40 ) exp = -0x40; + } + return softfloat_roundPackToF16( sign, exp, sig16 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f32.c new file mode 100644 index 000000000..77fcfdc11 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f32.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t extF80_to_f32( extFloat80_t a ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig; + struct commonNaN commonNaN; + uint_fast32_t uiZ, sig32; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToF32UI( &commonNaN ); + } else { + uiZ = packToF32UI( sign, 0xFF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig32 = softfloat_shortShiftRightJam64( sig, 33 ); + if ( ! (exp | sig32) ) { + uiZ = packToF32UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3F81; + if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return softfloat_roundPackToF32( sign, exp, sig32 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f64.c new file mode 100644 index 000000000..410d6622c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_f64.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t extF80_to_f64( extFloat80_t a ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + uint_fast64_t uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig; + struct commonNaN commonNaN; + uint_fast64_t uiZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + uiA0 = uA.s.signif; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! (exp | sig) ) { + uiZ = packToF64UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToF64UI( &commonNaN ); + } else { + uiZ = packToF64UI( sign, 0x7FF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = softfloat_shortShiftRightJam64( sig, 1 ); + exp -= 0x3C01; + if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return softfloat_roundPackToF64( sign, exp, sig ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32.c new file mode 100644 index 000000000..9acdc3c9b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32.c @@ -0,0 +1,83 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t + extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + bool sign; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow) + if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) { +#if (i32_fromNaN == i32_fromPosOverflow) + sign = 0; +#elif (i32_fromNaN == i32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return i32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x4032 - exp; + if ( shiftDist <= 0 ) shiftDist = 1; + sig = softfloat_shiftRightJam64( sig, shiftDist ); + return softfloat_roundToI32( sign, sig, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32_r_minMag.c new file mode 100644 index 000000000..03224678a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i32_r_minMag.c @@ -0,0 +1,97 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + bool sign; + int_fast32_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signExtF80UI64( uiA64 ); + if ( shiftDist < 33 ) { + if ( + (uiA64 == packToExtF80UI64( 1, 0x401E )) + && (sig < UINT64_C( 0x8000000100000000 )) + ) { + if ( exact && (sig & UINT64_C( 0x00000000FFFFFFFF )) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return -0x7FFFFFFF - 1; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? i32_fromNaN + : sign ? i32_fromNegOverflow : i32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + absZ = sig>>shiftDist; + if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t + extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + bool sign; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + uint_fast64_t sigExtra; + struct uint64_extra sig64Extra; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( shiftDist <= 0 ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( shiftDist ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sigExtra = 0; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist ); + sig = sig64Extra.v; + sigExtra = sig64Extra.extra; + } + return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i64_r_minMag.c new file mode 100644 index 000000000..8871d01d1 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_i64_r_minMag.c @@ -0,0 +1,94 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + bool sign; + int_fast64_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signExtF80UI64( uiA64 ); + if ( shiftDist <= 0 ) { + if ( + (uiA64 == packToExtF80UI64( 1, 0x403E )) + && (sig == UINT64_C( 0x8000000000000000 )) + ) { + return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + absZ = sig>>shiftDist; + if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return sign ? -absZ : absZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32.c new file mode 100644 index 000000000..581297731 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32.c @@ -0,0 +1,83 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t + extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + bool sign; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow) + if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) { +#if (ui32_fromNaN == ui32_fromPosOverflow) + sign = 0; +#elif (ui32_fromNaN == ui32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return ui32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x4032 - exp; + if ( shiftDist <= 0 ) shiftDist = 1; + sig = softfloat_shiftRightJam64( sig, shiftDist ); + return softfloat_roundToUI32( sign, sig, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32_r_minMag.c new file mode 100644 index 000000000..be2c53b1d --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui32_r_minMag.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + bool sign; + uint_fast32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signExtF80UI64( uiA64 ); + if ( sign || (shiftDist < 32) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + z = sig>>shiftDist; + if ( exact && ((uint_fast64_t) z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t + extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + bool sign; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + uint_fast64_t sigExtra; + struct uint64_extra sig64Extra; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + sign = signExtF80UI64( uiA64 ); + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( shiftDist < 0 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sigExtra = 0; + if ( shiftDist ) { + sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist ); + sig = sig64Extra.v; + sigExtra = sig64Extra.extra; + } + return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui64_r_minMag.c new file mode 100644 index 000000000..eca688c65 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/extF80_to_ui64_r_minMag.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact ) +{ + union { struct extFloat80M s; extFloat80_t f; } uA; + uint_fast16_t uiA64; + int_fast32_t exp; + uint_fast64_t sig; + int_fast32_t shiftDist; + bool sign; + uint_fast64_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.s.signExp; + exp = expExtF80UI64( uiA64 ); + sig = uA.s.signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( 64 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signExtF80UI64( uiA64 ); + if ( sign || (shiftDist < 0) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + z = sig>>shiftDist; + if ( exact && (z< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + const uint64_t *aWPtr, *bWPtr; + uint_fast64_t uiA64, uiA0; + bool signA; + uint_fast64_t uiB64, uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + float128_t + (*magsFuncPtr)( + uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); +#endif + + aWPtr = (const uint64_t *) aPtr; + bWPtr = (const uint64_t *) bPtr; + uiA64 = aWPtr[indexWord( 2, 1 )]; + uiA0 = aWPtr[indexWord( 2, 0 )]; + signA = signF128UI64( uiA64 ); + uiB64 = bWPtr[indexWord( 2, 1 )]; + uiB0 = bWPtr[indexWord( 2, 0 )]; + signB = signF128UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128; + *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + +#else + +void + f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + softfloat_addF128M( + (const uint32_t *) aPtr, + (const uint32_t *) bPtr, + (uint32_t *) zPtr, + false + ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_div.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_div.c new file mode 100644 index 000000000..b443548f5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_div.c @@ -0,0 +1,187 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + *zPtr = f128_div( *aPtr, *bPtr ); + +} + +#else + +void + f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t *zWPtr, uiA96; + bool signA; + int32_t expA; + uint32_t uiB96; + bool signB; + int32_t expB; + bool signZ; + uint32_t y[5], sigB[4]; + int32_t expZ; + uint32_t recip32; + int ix; + uint64_t q64; + uint32_t q, qs[3], uiZ96; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + signA = signF128UI96( uiA96 ); + expA = expF128UI96( uiA96 ); + uiB96 = bWPtr[indexWordHi( 4 )]; + signB = signF128UI96( uiB96 ); + expB = expF128UI96( uiB96 ); + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return; + if ( expA == 0x7FFF ) { + if ( expB == 0x7FFF ) goto invalid; + goto infinity; + } + goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = softfloat_shiftNormSigF128M( aWPtr, 13, y ); + expB = softfloat_shiftNormSigF128M( bWPtr, 13, sigB ); + if ( expA == -128 ) { + if ( expB == -128 ) goto invalid; + goto zero; + } + if ( expB == -128 ) { + softfloat_raiseFlags( softfloat_flag_infinite ); + goto infinity; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA - expB + 0x3FFE; + if ( softfloat_compare128M( y, sigB ) < 0 ) { + --expZ; + softfloat_add128M( y, y, y ); + } + recip32 = + softfloat_approxRecip32_1( + ((uint64_t) sigB[indexWord( 4, 3 )]<<32 | sigB[indexWord( 4, 2 )]) + >>30 + ); + ix = 3; + for (;;) { + q64 = (uint64_t) y[indexWordHi( 4 )] * recip32; + q = (q64 + 0x80000000)>>32; + --ix; + if ( ix < 0 ) break; + softfloat_remStep128MBy32( y, 29, sigB, q, y ); + if ( y[indexWordHi( 4 )] & 0x80000000 ) { + --q; + softfloat_add128M( y, sigB, y ); + } + qs[ix] = q; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ((q + 1) & 7) < 2 ) { + softfloat_remStep128MBy32( y, 29, sigB, q, y ); + if ( y[indexWordHi( 4 )] & 0x80000000 ) { + --q; + softfloat_add128M( y, sigB, y ); + } else if ( softfloat_compare128M( sigB, y ) <= 0 ) { + ++q; + softfloat_sub128M( y, sigB, y ); + } + if ( + y[indexWordLo( 4 )] || y[indexWord( 4, 1 )] + || (y[indexWord( 4, 2 )] | y[indexWord( 4, 3 )]) + ) { + q |= 1; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q64 = (uint64_t) q<<28; + y[indexWord( 5, 0 )] = q64; + q64 = ((uint64_t) qs[0]<<25) + (q64>>32); + y[indexWord( 5, 1 )] = q64; + q64 = ((uint64_t) qs[1]<<22) + (q64>>32); + y[indexWord( 5, 2 )] = q64; + q64 = ((uint64_t) qs[2]<<19) + (q64>>32); + y[indexWord( 5, 3 )] = q64; + y[indexWord( 5, 4 )] = q64>>32; + softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_invalidF128M( zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infinity: + uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 ); + goto uiZ96; + zero: + uiZ96 = packToF128UI96( signZ, 0, 0 ); + uiZ96: + zWPtr[indexWordHi( 4 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq.c new file mode 100644 index 000000000..497fdbf6f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return f128_eq( *aPtr, *bPtr ); + +} + +#else + +bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t wordA, wordB, uiA96, uiB96; + bool possibleOppositeZeros; + uint32_t mashWord; + + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + wordA = aWPtr[indexWord( 4, 2 )]; + wordB = bWPtr[indexWord( 4, 2 )]; + if ( wordA != wordB ) goto false_checkSigNaNs; + uiA96 = aWPtr[indexWordHi( 4 )]; + uiB96 = bWPtr[indexWordHi( 4 )]; + possibleOppositeZeros = false; + if ( uiA96 != uiB96 ) { + possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0); + if ( ! possibleOppositeZeros ) goto false_checkSigNaNs; + } + mashWord = wordA | wordB; + wordA = aWPtr[indexWord( 4, 1 )]; + wordB = bWPtr[indexWord( 4, 1 )]; + if ( wordA != wordB ) goto false_checkSigNaNs; + mashWord |= wordA | wordB; + wordA = aWPtr[indexWord( 4, 0 )]; + wordB = bWPtr[indexWord( 4, 0 )]; + if ( wordA != wordB ) goto false_checkSigNaNs; + if ( possibleOppositeZeros && ((mashWord | wordA | wordB) != 0) ) { + goto false_checkSigNaNs; + } + if ( ! softfloat_isNaNF128M( aWPtr ) && ! softfloat_isNaNF128M( bWPtr ) ) { + return true; + } + false_checkSigNaNs: + if ( + f128M_isSignalingNaN( (const float128_t *) aWPtr ) + || f128M_isSignalingNaN( (const float128_t *) bWPtr ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq_signaling.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq_signaling.c new file mode 100644 index 000000000..a9fa4d510 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_eq_signaling.c @@ -0,0 +1,92 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return f128_eq_signaling( *aPtr, *bPtr ); + +} + +#else + +bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t wordA, wordB, uiA96, uiB96; + bool possibleOppositeZeros; + uint32_t mashWord; + + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + wordA = aWPtr[indexWord( 4, 2 )]; + wordB = bWPtr[indexWord( 4, 2 )]; + if ( wordA != wordB ) return false; + uiA96 = aWPtr[indexWordHi( 4 )]; + uiB96 = bWPtr[indexWordHi( 4 )]; + possibleOppositeZeros = false; + if ( uiA96 != uiB96 ) { + possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0); + if ( ! possibleOppositeZeros ) return false; + } + mashWord = wordA | wordB; + wordA = aWPtr[indexWord( 4, 1 )]; + wordB = bWPtr[indexWord( 4, 1 )]; + if ( wordA != wordB ) return false; + mashWord |= wordA | wordB; + wordA = aWPtr[indexWord( 4, 0 )]; + wordB = bWPtr[indexWord( 4, 0 )]; + return + (wordA == wordB) + && (! possibleOppositeZeros || ((mashWord | wordA | wordB) == 0)); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le.c new file mode 100644 index 000000000..7306e45c3 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le.c @@ -0,0 +1,93 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool f128M_le( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return f128_le( *aPtr, *bPtr ); + +} + +#else + +bool f128M_le( const float128_t *aPtr, const float128_t *bPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t uiA96, uiB96; + bool signA, signB; + uint32_t wordA, wordB; + + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + uiA96 = aWPtr[indexWordHi( 4 )]; + uiB96 = bWPtr[indexWordHi( 4 )]; + signA = signF128UI96( uiA96 ); + signB = signF128UI96( uiB96 ); + if ( signA != signB ) { + if ( signA ) return true; + if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false; + wordA = aWPtr[indexWord( 4, 2 )]; + wordB = bWPtr[indexWord( 4, 2 )]; + if ( wordA | wordB ) return false; + wordA = aWPtr[indexWord( 4, 1 )]; + wordB = bWPtr[indexWord( 4, 1 )]; + if ( wordA | wordB ) return false; + wordA = aWPtr[indexWord( 4, 0 )]; + wordB = bWPtr[indexWord( 4, 0 )]; + return ((wordA | wordB) == 0); + } + if ( signA ) { + aWPtr = (const uint32_t *) bPtr; + bWPtr = (const uint32_t *) aPtr; + } + return (softfloat_compare128M( aWPtr, bWPtr ) <= 0); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le_quiet.c new file mode 100644 index 000000000..d9e442942 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_le_quiet.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return f128_le_quiet( *aPtr, *bPtr ); + +} + +#else + +bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t uiA96, uiB96; + bool signA, signB; + uint32_t wordA, wordB; + + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) { + if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + uiA96 = aWPtr[indexWordHi( 4 )]; + uiB96 = bWPtr[indexWordHi( 4 )]; + signA = signF128UI96( uiA96 ); + signB = signF128UI96( uiB96 ); + if ( signA != signB ) { + if ( signA ) return true; + if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false; + wordA = aWPtr[indexWord( 4, 2 )]; + wordB = bWPtr[indexWord( 4, 2 )]; + if ( wordA | wordB ) return false; + wordA = aWPtr[indexWord( 4, 1 )]; + wordB = bWPtr[indexWord( 4, 1 )]; + if ( wordA | wordB ) return false; + wordA = aWPtr[indexWord( 4, 0 )]; + wordB = bWPtr[indexWord( 4, 0 )]; + return ((wordA | wordB) == 0); + } + if ( signA ) { + aWPtr = (const uint32_t *) bPtr; + bWPtr = (const uint32_t *) aPtr; + } + return (softfloat_compare128M( aWPtr, bWPtr ) <= 0); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt.c new file mode 100644 index 000000000..d2f797fea --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt.c @@ -0,0 +1,93 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return f128_lt( *aPtr, *bPtr ); + +} + +#else + +bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t uiA96, uiB96; + bool signA, signB; + uint32_t wordA, wordB; + + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + uiA96 = aWPtr[indexWordHi( 4 )]; + uiB96 = bWPtr[indexWordHi( 4 )]; + signA = signF128UI96( uiA96 ); + signB = signF128UI96( uiB96 ); + if ( signA != signB ) { + if ( signB ) return false; + if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true; + wordA = aWPtr[indexWord( 4, 2 )]; + wordB = bWPtr[indexWord( 4, 2 )]; + if ( wordA | wordB ) return true; + wordA = aWPtr[indexWord( 4, 1 )]; + wordB = bWPtr[indexWord( 4, 1 )]; + if ( wordA | wordB ) return true; + wordA = aWPtr[indexWord( 4, 0 )]; + wordB = bWPtr[indexWord( 4, 0 )]; + return ((wordA | wordB) != 0); + } + if ( signA ) { + aWPtr = (const uint32_t *) bPtr; + bWPtr = (const uint32_t *) aPtr; + } + return (softfloat_compare128M( aWPtr, bWPtr ) < 0); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt_quiet.c new file mode 100644 index 000000000..adbddea71 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_lt_quiet.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return f128_lt_quiet( *aPtr, *bPtr ); + +} + +#else + +bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t uiA96, uiB96; + bool signA, signB; + uint32_t wordA, wordB; + + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) { + if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + uiA96 = aWPtr[indexWordHi( 4 )]; + uiB96 = bWPtr[indexWordHi( 4 )]; + signA = signF128UI96( uiA96 ); + signB = signF128UI96( uiB96 ); + if ( signA != signB ) { + if ( signB ) return false; + if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true; + wordA = aWPtr[indexWord( 4, 2 )]; + wordB = bWPtr[indexWord( 4, 2 )]; + if ( wordA | wordB ) return true; + wordA = aWPtr[indexWord( 4, 1 )]; + wordB = bWPtr[indexWord( 4, 1 )]; + if ( wordA | wordB ) return true; + wordA = aWPtr[indexWord( 4, 0 )]; + wordB = bWPtr[indexWord( 4, 0 )]; + return ((wordA | wordB) != 0); + } + if ( signA ) { + aWPtr = (const uint32_t *) bPtr; + bWPtr = (const uint32_t *) aPtr; + } + return (softfloat_compare128M( aWPtr, bWPtr ) < 0); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mul.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mul.c new file mode 100644 index 000000000..4b8292a27 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mul.c @@ -0,0 +1,158 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + *zPtr = f128_mul( *aPtr, *bPtr ); + +} + +#else + +void + f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t *zWPtr; + uint32_t uiA96; + int32_t expA; + uint32_t uiB96; + int32_t expB; + bool signZ; + const uint32_t *ptr; + uint32_t uiZ96, sigA[4]; + uint_fast8_t shiftDist; + uint32_t sigB[4]; + int32_t expZ; + uint32_t sigProd[8], *extSigZPtr; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + expA = expF128UI96( uiA96 ); + uiB96 = bWPtr[indexWordHi( 4 )]; + expB = expF128UI96( uiB96 ); + signZ = signF128UI96( uiA96 ) ^ signF128UI96( uiB96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return; + ptr = aWPtr; + if ( ! expA ) goto possiblyInvalid; + if ( ! expB ) { + ptr = bWPtr; + possiblyInvalid: + if ( + ! fracF128UI96( ptr[indexWordHi( 4 )] ) + && ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )] + | ptr[indexWord( 4, 0 )]) + ) { + softfloat_invalidF128M( zWPtr ); + return; + } + } + uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 ); + goto uiZ96; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA ) { + sigA[indexWordHi( 4 )] = fracF128UI96( uiA96 ) | 0x00010000; + sigA[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + sigA[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + sigA[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + } else { + expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA ); + if ( expA == -128 ) goto zero; + } + if ( expB ) { + sigB[indexWordHi( 4 )] = fracF128UI96( uiB96 ) | 0x00010000; + sigB[indexWord( 4, 2 )] = bWPtr[indexWord( 4, 2 )]; + sigB[indexWord( 4, 1 )] = bWPtr[indexWord( 4, 1 )]; + sigB[indexWord( 4, 0 )] = bWPtr[indexWord( 4, 0 )]; + } else { + expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigB ); + if ( expB == -128 ) goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x4000; + softfloat_mul128MTo256M( sigA, sigB, sigProd ); + if ( + sigProd[indexWord( 8, 2 )] + || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )]) + ) { + sigProd[indexWord( 8, 3 )] |= 1; + } + extSigZPtr = &sigProd[indexMultiwordHi( 8, 5 )]; + shiftDist = 16; + if ( extSigZPtr[indexWordHi( 5 )] & 2 ) { + ++expZ; + shiftDist = 15; + } + softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr ); + softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ96 = packToF128UI96( signZ, 0, 0 ); + uiZ96: + zWPtr[indexWordHi( 4 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mulAdd.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mulAdd.c new file mode 100644 index 000000000..2b0b7fe26 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_mulAdd.c @@ -0,0 +1,92 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + f128M_mulAdd( + const float128_t *aPtr, + const float128_t *bPtr, + const float128_t *cPtr, + float128_t *zPtr + ) +{ + const uint64_t *aWPtr, *bWPtr, *cWPtr; + uint_fast64_t uiA64, uiA0; + uint_fast64_t uiB64, uiB0; + uint_fast64_t uiC64, uiC0; + + aWPtr = (const uint64_t *) aPtr; + bWPtr = (const uint64_t *) bPtr; + cWPtr = (const uint64_t *) cPtr; + uiA64 = aWPtr[indexWord( 2, 1 )]; + uiA0 = aWPtr[indexWord( 2, 0 )]; + uiB64 = bWPtr[indexWord( 2, 1 )]; + uiB0 = bWPtr[indexWord( 2, 0 )]; + uiC64 = cWPtr[indexWord( 2, 1 )]; + uiC0 = cWPtr[indexWord( 2, 0 )]; + *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 ); + +} + +#else + +void + f128M_mulAdd( + const float128_t *aPtr, + const float128_t *bPtr, + const float128_t *cPtr, + float128_t *zPtr + ) +{ + + softfloat_mulAddF128M( + (const uint32_t *) aPtr, + (const uint32_t *) bPtr, + (const uint32_t *) cPtr, + (uint32_t *) zPtr, + 0 + ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_rem.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_rem.c new file mode 100644 index 000000000..39aafdd6a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_rem.c @@ -0,0 +1,182 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + *zPtr = f128_rem( *aPtr, *bPtr ); + +} + +#else + +void + f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + const uint32_t *aWPtr, *bWPtr; + uint32_t *zWPtr, uiA96; + int32_t expA, expB; + uint32_t x[4], rem1[5], *remPtr; + bool signRem; + int32_t expDiff; + uint32_t q, recip32; + uint64_t q64; + uint32_t rem2[5], *altRemPtr, *newRemPtr, wordMeanRem; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + bWPtr = (const uint32_t *) bPtr; + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + expA = expF128UI96( uiA96 ); + expB = expF128UI96( bWPtr[indexWordHi( 4 )] ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return; + if ( expA == 0x7FFF ) goto invalid; + goto copyA; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA < expB - 1 ) goto copyA; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expB = softfloat_shiftNormSigF128M( bWPtr, 13, x ); + if ( expB == -128 ) goto invalid; + remPtr = &rem1[indexMultiwordLo( 5, 4 )]; + expA = softfloat_shiftNormSigF128M( aWPtr, 13, remPtr ); + if ( expA == -128 ) goto copyA; + signRem = signF128UI96( uiA96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( expDiff < 1 ) { + if ( expDiff < -1 ) goto copyA; + if ( expDiff ) { + --expB; + softfloat_add128M( x, x, x ); + q = 0; + } else { + q = (softfloat_compare128M( x, remPtr ) <= 0); + if ( q ) softfloat_sub128M( remPtr, x, remPtr ); + } + } else { + recip32 = + softfloat_approxRecip32_1( + ((uint64_t) x[indexWord( 4, 3 )]<<32 | x[indexWord( 4, 2 )]) + >>30 + ); + expDiff -= 30; + for (;;) { + q64 = (uint64_t) remPtr[indexWordHi( 4 )] * recip32; + if ( expDiff < 0 ) break; + q = (q64 + 0x80000000)>>32; + softfloat_remStep128MBy32( remPtr, 29, x, q, remPtr ); + if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) { + softfloat_add128M( remPtr, x, remPtr ); + } + expDiff -= 29; + } + /*-------------------------------------------------------------------- + | (`expDiff' cannot be less than -29 here.) + *--------------------------------------------------------------------*/ + q = (uint32_t) (q64>>32)>>(~expDiff & 31); + softfloat_remStep128MBy32( remPtr, expDiff + 30, x, q, remPtr ); + if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) { + altRemPtr = &rem2[indexMultiwordLo( 5, 4 )]; + softfloat_add128M( remPtr, x, altRemPtr ); + goto selectRem; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + altRemPtr = &rem2[indexMultiwordLo( 5, 4 )]; + do { + ++q; + newRemPtr = altRemPtr; + softfloat_sub128M( remPtr, x, newRemPtr ); + altRemPtr = remPtr; + remPtr = newRemPtr; + } while ( ! (remPtr[indexWordHi( 4 )] & 0x80000000) ); + selectRem: + softfloat_add128M( remPtr, altRemPtr, x ); + wordMeanRem = x[indexWordHi( 4 )]; + if ( + (wordMeanRem & 0x80000000) + || (! wordMeanRem && (q & 1) && ! x[indexWord( 4, 0 )] + && ! (x[indexWord( 4, 2 )] | x[indexWord( 4, 1 )])) + ) { + remPtr = altRemPtr; + } + if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) { + signRem = ! signRem; + softfloat_negX128M( remPtr ); + } + remPtr -= indexMultiwordLo( 5, 4 ); + remPtr[indexWordHi( 5 )] = 0; + softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_invalidF128M( zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + copyA: + zWPtr[indexWordHi( 4 )] = uiA96; + zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_roundToInt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_roundToInt.c new file mode 100644 index 000000000..b96d742b2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_roundToInt.c @@ -0,0 +1,223 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + f128M_roundToInt( + const float128_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + float128_t *zPtr + ) +{ + + *zPtr = f128_roundToInt( *aPtr, roundingMode, exact ); + +} + +#else + +void + f128M_roundToInt( + const float128_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + float128_t *zPtr + ) +{ + const uint32_t *aWPtr; + uint32_t *zWPtr; + uint32_t ui96; + int32_t exp; + uint32_t sigExtra; + bool sign; + uint_fast8_t bitPos; + bool roundNear; + unsigned int index, lastIndex; + bool extra; + uint32_t wordA, bit, wordZ; + uint_fast8_t carry; + uint32_t extrasMask; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + ui96 = aWPtr[indexWordHi( 4 )]; + exp = expF128UI96( ui96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp < 0x3FFF ) { + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + sigExtra = aWPtr[indexWord( 4, 2 )]; + if ( !sigExtra ) { + sigExtra = aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )]; + } + if ( !sigExtra && !(ui96 & 0x7FFFFFFF) ) goto ui96; + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + sign = signF128UI96( ui96 ); + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( !fracF128UI96( ui96 ) && !sigExtra ) break; + case softfloat_round_near_maxMag: + if ( exp == 0x3FFE ) goto mag1; + break; + case softfloat_round_min: + if ( sign ) goto mag1; + break; + case softfloat_round_max: + if ( !sign ) goto mag1; + break; +#ifdef SOFTFLOAT_ROUND_ODD + case softfloat_round_odd: + goto mag1; +#endif + } + ui96 = packToF128UI96( sign, 0, 0 ); + goto ui96; + mag1: + ui96 = packToF128UI96( sign, 0x3FFF, 0 ); + goto ui96; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x406F <= exp ) { + if ( + (exp == 0x7FFF) + && (fracF128UI96( ui96 ) + || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )])) + ) { + softfloat_propagateNaNF128M( aWPtr, 0, zWPtr ); + return; + } + zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + goto ui96; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + bitPos = 0x406F - exp; + roundNear = + (roundingMode == softfloat_round_near_maxMag) + || (roundingMode == softfloat_round_near_even); + bitPos -= roundNear; + index = indexWordLo( 4 ); + lastIndex = indexWordHi( 4 ); + extra = 0; + for (;;) { + wordA = aWPtr[index]; + if ( bitPos < 32 ) break; + if ( wordA ) extra = 1; + zWPtr[index] = 0; + index += wordIncr; + bitPos -= 32; + } + bit = (uint32_t) 1< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr ) +{ + + *zPtr = f128_sqrt( *aPtr ); + +} + +#else + +void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr ) +{ + const uint32_t *aWPtr; + uint32_t *zWPtr; + uint32_t uiA96; + bool signA; + int32_t rawExpA; + uint32_t rem[6]; + int32_t expA, expZ; + uint64_t rem64; + uint32_t sig32A, recipSqrt32, sig32Z, qs[3], q; + uint64_t sig64Z; + uint32_t term[5]; + uint64_t x64; + uint32_t y[5], rem32; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + signA = signF128UI96( uiA96 ); + rawExpA = expF128UI96( uiA96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( rawExpA == 0x7FFF ) { + if ( + fracF128UI96( uiA96 ) + || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )]) + ) { + softfloat_propagateNaNF128M( aWPtr, 0, zWPtr ); + return; + } + if ( ! signA ) goto copyA; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = softfloat_shiftNormSigF128M( aWPtr, 13 - (rawExpA & 1), rem ); + if ( expA == -128 ) goto copyA; + if ( signA ) goto invalid; + /*------------------------------------------------------------------------ + | (`sig32Z' is guaranteed to be a lower bound on the square root of + | `sig32A', which makes `sig32Z' also a lower bound on the square root of + | `sigA'.) + *------------------------------------------------------------------------*/ + expZ = ((expA - 0x3FFF)>>1) + 0x3FFE; + expA &= 1; + rem64 = (uint64_t) rem[indexWord( 4, 3 )]<<32 | rem[indexWord( 4, 2 )]; + if ( expA ) { + if ( ! rawExpA ) { + softfloat_shortShiftRight128M( rem, 1, rem ); + rem64 >>= 1; + } + sig32A = rem64>>29; + } else { + sig32A = rem64>>30; + } + recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A ); + sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32; + if ( expA ) sig32Z >>= 1; + qs[2] = sig32Z; + rem64 -= (uint64_t) sig32Z * sig32Z; + rem[indexWord( 4, 3 )] = rem64>>32; + rem[indexWord( 4, 2 )] = rem64; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32; + sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3); + term[indexWord( 4, 3 )] = 0; + term[indexWord( 4, 0 )] = 0; + /*------------------------------------------------------------------------ + | (Repeating this loop is a rare occurrence.) + *------------------------------------------------------------------------*/ + for (;;) { + x64 = ((uint64_t) sig32Z<<32) + sig64Z; + term[indexWord( 4, 2 )] = x64>>32; + term[indexWord( 4, 1 )] = x64; + softfloat_remStep128MBy32( rem, 29, term, q, y ); + rem32 = y[indexWord( 4, 3 )]; + if ( ! (rem32 & 0x80000000) ) break; + --q; + sig64Z -= 1<<3; + } + qs[1] = q; + rem64 = (uint64_t) rem32<<32 | y[indexWord( 4, 2 )]; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32; + if ( rem64>>34 ) q += recipSqrt32; + sig64Z <<= 1; + /*------------------------------------------------------------------------ + | (Repeating this loop is a rare occurrence.) + *------------------------------------------------------------------------*/ + for (;;) { + x64 = sig64Z + (q>>26); + term[indexWord( 4, 2 )] = x64>>32; + term[indexWord( 4, 1 )] = x64; + term[indexWord( 4, 0 )] = q<<6; + softfloat_remStep128MBy32( + y, 29, term, q, &rem[indexMultiwordHi( 6, 4 )] ); + rem32 = rem[indexWordHi( 6 )]; + if ( ! (rem32 & 0x80000000) ) break; + --q; + } + qs[0] = q; + rem64 = (uint64_t) rem32<<32 | rem[indexWord( 6, 4 )]; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2; + if ( rem64>>34 ) q += recipSqrt32; + x64 = (uint64_t) q<<27; + y[indexWord( 5, 0 )] = x64; + x64 = ((uint64_t) qs[0]<<24) + (x64>>32); + y[indexWord( 5, 1 )] = x64; + x64 = ((uint64_t) qs[1]<<21) + (x64>>32); + y[indexWord( 5, 2 )] = x64; + x64 = ((uint64_t) qs[2]<<18) + (x64>>32); + y[indexWord( 5, 3 )] = x64; + y[indexWord( 5, 4 )] = x64>>32; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (q & 0xF) <= 2 ) { + q &= ~3; + y[indexWordLo( 5 )] = q<<27; + term[indexWord( 5, 4 )] = 0; + term[indexWord( 5, 3 )] = 0; + term[indexWord( 5, 2 )] = 0; + term[indexWord( 5, 1 )] = q>>6; + term[indexWord( 5, 0 )] = q<<26; + softfloat_sub160M( y, term, term ); + rem[indexWord( 6, 1 )] = 0; + rem[indexWord( 6, 0 )] = 0; + softfloat_remStep160MBy32( + &rem[indexMultiwordLo( 6, 5 )], + 14, + term, + q, + &rem[indexMultiwordLo( 6, 5 )] + ); + rem32 = rem[indexWord( 6, 4 )]; + if ( rem32 & 0x80000000 ) { + softfloat_sub1X160M( y ); + } else { + if ( + rem32 || rem[indexWord( 6, 0 )] || rem[indexWord( 6, 1 )] + || (rem[indexWord( 6, 3 )] | rem[indexWord( 6, 2 )]) + ) { + y[indexWordLo( 5 )] |= 1; + } + } + } + softfloat_roundPackMToF128M( 0, expZ, y, zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_invalidF128M( zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + copyA: + zWPtr[indexWordHi( 4 )] = uiA96; + zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_sub.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_sub.c new file mode 100644 index 000000000..5d65c799f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_sub.c @@ -0,0 +1,97 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void + f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + const uint64_t *aWPtr, *bWPtr; + uint_fast64_t uiA64, uiA0; + bool signA; + uint_fast64_t uiB64, uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + float128_t + (*magsFuncPtr)( + uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); +#endif + + aWPtr = (const uint64_t *) aPtr; + bWPtr = (const uint64_t *) bPtr; + uiA64 = aWPtr[indexWord( 2, 1 )]; + uiA0 = aWPtr[indexWord( 2, 0 )]; + signA = signF128UI64( uiA64 ); + uiB64 = bWPtr[indexWord( 2, 1 )]; + uiB0 = bWPtr[indexWord( 2, 0 )]; + signB = signF128UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128; + *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + +#else + +void + f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + softfloat_addF128M( + (const uint32_t *) aPtr, + (const uint32_t *) bPtr, + (uint32_t *) zPtr, + true + ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_extF80M.c new file mode 100644 index 000000000..b0340c794 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_extF80M.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr ) +{ + + *zPtr = f128_to_extF80( *aPtr ); + +} + +#else + +void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr ) +{ + const uint32_t *aWPtr; + struct extFloat80M *zSPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + struct commonNaN commonNaN; + uint32_t sig[4]; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + zSPtr = (struct extFloat80M *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( softfloat_isNaNF128M( aWPtr ) ) { + softfloat_f128MToCommonNaN( aWPtr, &commonNaN ); + softfloat_commonNaNToExtF80M( &commonNaN, zSPtr ); + return; + } + zSPtr->signExp = packToExtF80UI64( sign, 0x7FFF ); + zSPtr->signif = UINT64_C( 0x8000000000000000 ); + return; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp = softfloat_shiftNormSigF128M( aWPtr, 15, sig ); + if ( exp == -128 ) { + zSPtr->signExp = packToExtF80UI64( sign, 0 ); + zSPtr->signif = 0; + return; + } + if ( sig[indexWord( 4, 0 )] ) sig[indexWord( 4, 1 )] |= 1; + softfloat_roundPackMToExtF80M( + sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f16.c new file mode 100644 index 000000000..95109a771 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f16.c @@ -0,0 +1,113 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +float16_t f128M_to_f16( const float128_t *aPtr ) +{ + + return f128_to_f16( *aPtr ); + +} + +#else + +float16_t f128M_to_f16( const float128_t *aPtr ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint32_t frac32; + struct commonNaN commonNaN; + uint16_t uiZ, frac16; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + frac32 = + fracF128UI96( uiA96 ) + | ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )]) + != 0); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( frac32 ) { + softfloat_f128MToCommonNaN( aWPtr, &commonNaN ); + uiZ = softfloat_commonNaNToF16UI( &commonNaN ); + } else { + uiZ = packToF16UI( sign, 0x1F, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac16 = frac32>>2 | (frac32 & 3); + if ( ! (exp | frac16) ) { + uiZ = packToF16UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3FF1; + if ( sizeof (int_fast16_t) < sizeof (int32_t) ) { + if ( exp < -0x40 ) exp = -0x40; + } + return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f32.c new file mode 100644 index 000000000..4542deb0c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f32.c @@ -0,0 +1,109 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +float32_t f128M_to_f32( const float128_t *aPtr ) +{ + + return f128_to_f32( *aPtr ); + +} + +#else + +float32_t f128M_to_f32( const float128_t *aPtr ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint64_t frac64; + struct commonNaN commonNaN; + uint32_t uiZ, frac32; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + frac64 = + (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )] + | ((aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )]) != 0); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( frac64 ) { + softfloat_f128MToCommonNaN( aWPtr, &commonNaN ); + uiZ = softfloat_commonNaNToF32UI( &commonNaN ); + } else { + uiZ = packToF32UI( sign, 0xFF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac32 = softfloat_shortShiftRightJam64( frac64, 18 ); + if ( ! (exp | frac32) ) { + uiZ = packToF32UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3F81; + if ( sizeof (int_fast16_t) < sizeof (int32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f64.c new file mode 100644 index 000000000..6213bb7f5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_f64.c @@ -0,0 +1,112 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +float64_t f128M_to_f64( const float128_t *aPtr ) +{ + + return f128_to_f64( *aPtr ); + +} + +#else + +float64_t f128M_to_f64( const float128_t *aPtr ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint64_t frac64; + struct commonNaN commonNaN; + uint64_t uiZ; + uint32_t frac32; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + frac64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( frac64 || aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) { + softfloat_f128MToCommonNaN( aWPtr, &commonNaN ); + uiZ = softfloat_commonNaNToF64UI( &commonNaN ); + } else { + uiZ = packToF64UI( sign, 0x7FF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac32 = aWPtr[indexWord( 4, 1 )]; + frac64 = frac64<<14 | frac32>>18; + if ( (frac32 & 0x0003FFFF) || aWPtr[indexWord( 4, 0 )] ) frac64 |= 1; + if ( ! (exp | frac64) ) { + uiZ = packToF64UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3C01; + if ( sizeof (int_fast16_t) < sizeof (int32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return + softfloat_roundPackToF64( + sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32.c new file mode 100644 index 000000000..54cc6f603 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast32_t + f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return f128_to_i32( *aPtr, roundingMode, exact ); + +} + +#else + +int_fast32_t + f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint64_t sig64; + int32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]; + if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow) + if ( (exp == 0x7FFF) && sig64 ) { +#if (i32_fromNaN == i32_fromPosOverflow) + sign = 0; +#elif (i32_fromNaN == i32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return i32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 ); + shiftDist = 0x4023 - exp; + if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist ); + return softfloat_roundToI32( sign, sig64, roundingMode, exact ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32_r_minMag.c new file mode 100644 index 000000000..1f22039de --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i32_r_minMag.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact ) +{ + + return f128_to_i32_r_minMag( *aPtr, exact ); + +} + +#else + +int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint64_t sig64; + int32_t shiftDist; + uint32_t absZ, uiZ; + union { uint32_t ui; int32_t i; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]; + if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp < 0x3FFF ) { + if ( exact && (exp | sig64) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x401F <= exp ) goto invalid; + shiftDist = 0x402F - exp; + sig64 |= UINT64_C( 0x0001000000000000 ); + absZ = sig64>>shiftDist; + uiZ = sign ? -absZ : absZ; + if ( uiZ>>31 != sign ) goto invalid; + if ( exact && ((uint64_t) absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast64_t + f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return f128_to_i64( *aPtr, roundingMode, exact ); + +} + +#else + +int_fast64_t + f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint32_t sig96; + int32_t shiftDist; + uint32_t sig[4]; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + sig96 = fracF128UI96( uiA96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x404F - exp; + if ( shiftDist < 17 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) + && (sig96 + || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )])) + ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig96 |= 0x00010000; + sig[indexWord( 4, 3 )] = sig96; + sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + softfloat_shiftRightJam128M( sig, shiftDist, sig ); + return + softfloat_roundMToI64( + sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i64_r_minMag.c new file mode 100644 index 000000000..da3d28ad0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_i64_r_minMag.c @@ -0,0 +1,124 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact ) +{ + + return f128_to_i64_r_minMag( *aPtr, exact ); + +} + +#else + +int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint32_t sig96; + int32_t shiftDist; + uint32_t sig[4]; + uint64_t uiZ; + union { uint64_t ui; int64_t i; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + sig96 = fracF128UI96( uiA96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( shiftDist < 0 ) goto invalid; + if ( exact ) { + if ( exp ) sig96 |= 0x00010000; + sig[indexWord( 4, 3 )] = sig96; + sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + softfloat_shiftRightJam128M( sig, shiftDist + 17, sig ); + uiZ = (uint64_t) sig[indexWord( 4, 2 )]<<32 | sig[indexWord( 4, 1 )]; + if ( uiZ>>63 && (! sign || (uiZ != UINT64_C( 0x8000000000000000 ))) ) { + goto invalid; + } + if ( sig[indexWordLo( 4 )] ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + } else { + if ( 64 <= shiftDist ) return 0; + uiZ = + (uint64_t) sig96<<47 + | (uint64_t) aWPtr[indexWord( 4, 2 )]<<15 + | aWPtr[indexWord( 4, 1 )]>>17; + if ( shiftDist ) { + uiZ |= UINT64_C( 0x8000000000000000 ); + uiZ >>= shiftDist; + } else { + if ( uiZ || ! sign ) goto invalid; + uiZ |= UINT64_C( 0x8000000000000000 ); + } + } + if ( sign ) uiZ = -uiZ; + uZ.ui = uiZ; + return uZ.i; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) + && (sig96 + || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )])) + ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32.c new file mode 100644 index 000000000..c1baa063a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast32_t + f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return f128_to_ui32( *aPtr, roundingMode, exact ); + +} + +#else + +uint_fast32_t + f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint64_t sig64; + int32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]; + if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow) + if ( (exp == 0x7FFF) && sig64 ) { +#if (ui32_fromNaN == ui32_fromPosOverflow) + sign = 0; +#elif (ui32_fromNaN == ui32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return ui32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 ); + shiftDist = 0x4023 - exp; + if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist ); + return softfloat_roundToUI32( sign, sig64, roundingMode, exact ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32_r_minMag.c new file mode 100644 index 000000000..a1aca621a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui32_r_minMag.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact ) +{ + + return f128_to_ui32_r_minMag( *aPtr, exact ); + +} + +#else + +uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + int32_t exp; + uint64_t sig64; + int32_t shiftDist; + bool sign; + uint32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + exp = expF128UI96( uiA96 ); + sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]; + if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x402F - exp; + if ( 49 <= shiftDist ) { + if ( exact && (exp | sig64) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF128UI96( uiA96 ); + if ( sign || (shiftDist < 17) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && sig64 ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig64 |= UINT64_C( 0x0001000000000000 ); + z = sig64>>shiftDist; + if ( exact && ((uint64_t) z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast64_t + f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return f128_to_ui64( *aPtr, roundingMode, exact ); + +} + +#else + +uint_fast64_t + f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint32_t sig96; + int32_t shiftDist; + uint32_t sig[4]; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + sig96 = fracF128UI96( uiA96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x404F - exp; + if ( shiftDist < 17 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) + && (sig96 + || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )])) + ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig96 |= 0x00010000; + sig[indexWord( 4, 3 )] = sig96; + sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + softfloat_shiftRightJam128M( sig, shiftDist, sig ); + return + softfloat_roundMToUI64( + sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui64_r_minMag.c new file mode 100644 index 000000000..7a1b60295 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128M_to_ui64_r_minMag.c @@ -0,0 +1,114 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact ) +{ + + return f128_to_ui64_r_minMag( *aPtr, exact ); + +} + +#else + +uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact ) +{ + const uint32_t *aWPtr; + uint32_t uiA96; + bool sign; + int32_t exp; + uint32_t sig96; + int32_t shiftDist; + uint32_t sig[4]; + uint64_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + aWPtr = (const uint32_t *) aPtr; + uiA96 = aWPtr[indexWordHi( 4 )]; + sign = signF128UI96( uiA96 ); + exp = expF128UI96( uiA96 ); + sig96 = fracF128UI96( uiA96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x403E - exp; + if ( shiftDist < 0 ) goto invalid; + if ( exact ) { + if ( exp ) sig96 |= 0x00010000; + sig[indexWord( 4, 3 )] = sig96; + sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + softfloat_shiftRightJam128M( sig, shiftDist + 17, sig ); + z = (uint64_t) sig[indexWord( 4, 2 )]<<32 | sig[indexWord( 4, 1 )]; + if ( sign && z ) goto invalid; + if ( sig[indexWordLo( 4 )] ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + } else { + if ( 64 <= shiftDist ) return 0; + if ( sign ) goto invalid; + z = UINT64_C( 0x8000000000000000 ) + | (uint64_t) sig96<<47 + | (uint64_t) aWPtr[indexWord( 4, 2 )]<<15 + | aWPtr[indexWord( 4, 1 )]>>17; + z >>= shiftDist; + } + return z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) + && (sig96 + || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )])) + ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_add.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_add.c new file mode 100644 index 000000000..e9caba682 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_add.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t f128_add( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool signA; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + float128_t + (*magsFuncPtr)( + uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); +#endif + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + signA = signF128UI64( uiA64 ); + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + signB = signF128UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128; + return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_div.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_div.c new file mode 100644 index 000000000..0693db754 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_div.c @@ -0,0 +1,199 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t f128_div( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool signA; + int_fast32_t expA; + struct uint128 sigA; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signB; + int_fast32_t expB; + struct uint128 sigB; + bool signZ; + struct exp32_sig128 normExpSig; + int_fast32_t expZ; + struct uint128 rem; + uint_fast32_t recip32; + int ix; + uint_fast64_t q64; + uint_fast32_t q; + struct uint128 term; + uint_fast32_t qs[3]; + uint_fast64_t sigZExtra; + struct uint128 sigZ, uiZ; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + signA = signF128UI64( uiA64 ); + expA = expF128UI64( uiA64 ); + sigA.v64 = fracF128UI64( uiA64 ); + sigA.v0 = uiA0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + signB = signF128UI64( uiB64 ); + expB = expF128UI64( uiB64 ); + sigB.v64 = fracF128UI64( uiB64 ); + sigB.v0 = uiB0; + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( sigA.v64 | sigA.v0 ) goto propagateNaN; + if ( expB == 0x7FFF ) { + if ( sigB.v64 | sigB.v0 ) goto propagateNaN; + goto invalid; + } + goto infinity; + } + if ( expB == 0x7FFF ) { + if ( sigB.v64 | sigB.v0 ) goto propagateNaN; + goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! (sigB.v64 | sigB.v0) ) { + if ( ! (expA | sigA.v64 | sigA.v0) ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinite ); + goto infinity; + } + normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! (sigA.v64 | sigA.v0) ) goto zero; + normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA - expB + 0x3FFE; + sigA.v64 |= UINT64_C( 0x0001000000000000 ); + sigB.v64 |= UINT64_C( 0x0001000000000000 ); + rem = sigA; + if ( softfloat_lt128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 ) ) { + --expZ; + rem = softfloat_add128( sigA.v64, sigA.v0, sigA.v64, sigA.v0 ); + } + recip32 = softfloat_approxRecip32_1( sigB.v64>>17 ); + ix = 3; + for (;;) { + q64 = (uint_fast64_t) (uint32_t) (rem.v64>>19) * recip32; + q = (q64 + 0x80000000)>>32; + --ix; + if ( ix < 0 ) break; + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + term = softfloat_mul128By32( sigB.v64, sigB.v0, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + --q; + rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 ); + } + qs[ix] = q; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ((q + 1) & 7) < 2 ) { + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + term = softfloat_mul128By32( sigB.v64, sigB.v0, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + --q; + rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 ); + } else if ( softfloat_le128( sigB.v64, sigB.v0, rem.v64, rem.v0 ) ) { + ++q; + rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 ); + } + if ( rem.v64 | rem.v0 ) q |= 1; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sigZExtra = (uint64_t) ((uint_fast64_t) q<<60); + term = softfloat_shortShiftLeft128( 0, qs[1], 54 ); + sigZ = + softfloat_add128( + (uint_fast64_t) qs[2]<<19, ((uint_fast64_t) qs[0]<<25) + (q>>4), + term.v64, term.v0 + ); + return + softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infinity: + uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 ); + goto uiZ0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ.v64 = packToF128UI64( signZ, 0, 0 ); + uiZ0: + uiZ.v0 = 0; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq.c new file mode 100644 index 000000000..9462fc2ab --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f128_eq( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNF128UI( uiA64, uiA0 ) + || softfloat_isSigNaNF128UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + return + (uiA0 == uiB0) + && ( (uiA64 == uiB64) + || (! uiA0 && ! ((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))) + ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq_signaling.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq_signaling.c new file mode 100644 index 000000000..5d0819d29 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_eq_signaling.c @@ -0,0 +1,67 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f128_eq_signaling( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + return + (uiA0 == uiB0) + && ( (uiA64 == uiB64) + || (! uiA0 && ! ((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))) + ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_isSignalingNaN.c new file mode 100644 index 000000000..a764ff6bf --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_isSignalingNaN.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f128_isSignalingNaN( float128_t a ) +{ + union ui128_f128 uA; + + uA.f = a; + return softfloat_isSigNaNF128UI( uA.ui.v64, uA.ui.v0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le.c new file mode 100644 index 000000000..521a1cb03 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le.c @@ -0,0 +1,72 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f128_le( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF128UI64( uiA64 ); + signB = signF128UI64( uiB64 ); + return + (signA != signB) + ? signA + || ! (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + | uiA0 | uiB0) + : ((uiA64 == uiB64) && (uiA0 == uiB0)) + || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le_quiet.c new file mode 100644 index 000000000..820b28b81 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_le_quiet.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f128_le_quiet( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNF128UI( uiA64, uiA0 ) + || softfloat_isSigNaNF128UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF128UI64( uiA64 ); + signB = signF128UI64( uiB64 ); + return + (signA != signB) + ? signA + || ! (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + | uiA0 | uiB0) + : ((uiA64 == uiB64) && (uiA0 == uiB0)) + || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt.c new file mode 100644 index 000000000..fa46ae2bc --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt.c @@ -0,0 +1,72 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f128_lt( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF128UI64( uiA64 ); + signB = signF128UI64( uiB64 ); + return + (signA != signB) + ? signA + && (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + | uiA0 | uiB0) + : ((uiA64 != uiB64) || (uiA0 != uiB0)) + && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt_quiet.c new file mode 100644 index 000000000..d491de2f2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_lt_quiet.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f128_lt_quiet( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signA, signB; + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) { + if ( + softfloat_isSigNaNF128UI( uiA64, uiA0 ) + || softfloat_isSigNaNF128UI( uiB64, uiB0 ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF128UI64( uiA64 ); + signB = signF128UI64( uiB64 ); + return + (signA != signB) + ? signA + && (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + | uiA0 | uiB0) + : ((uiA64 != uiB64) || (uiA0 != uiB0)) + && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mul.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mul.c new file mode 100644 index 000000000..24af86a24 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mul.c @@ -0,0 +1,163 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t f128_mul( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool signA; + int_fast32_t expA; + struct uint128 sigA; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signB; + int_fast32_t expB; + struct uint128 sigB; + bool signZ; + uint_fast64_t magBits; + struct exp32_sig128 normExpSig; + int_fast32_t expZ; + uint64_t sig256Z[4]; + uint_fast64_t sigZExtra; + struct uint128 sigZ; + struct uint128_extra sig128Extra; + struct uint128 uiZ; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + signA = signF128UI64( uiA64 ); + expA = expF128UI64( uiA64 ); + sigA.v64 = fracF128UI64( uiA64 ); + sigA.v0 = uiA0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + signB = signF128UI64( uiB64 ); + expB = expF128UI64( uiB64 ); + sigB.v64 = fracF128UI64( uiB64 ); + sigB.v0 = uiB0; + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( + (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0)) + ) { + goto propagateNaN; + } + magBits = expB | sigB.v64 | sigB.v0; + goto infArg; + } + if ( expB == 0x7FFF ) { + if ( sigB.v64 | sigB.v0 ) goto propagateNaN; + magBits = expA | sigA.v64 | sigA.v0; + goto infArg; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! (sigA.v64 | sigA.v0) ) goto zero; + normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! (sigB.v64 | sigB.v0) ) goto zero; + normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x4000; + sigA.v64 |= UINT64_C( 0x0001000000000000 ); + sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 16 ); + softfloat_mul128To256M( sigA.v64, sigA.v0, sigB.v64, sigB.v0, sig256Z ); + sigZExtra = sig256Z[indexWord( 4, 1 )] | (sig256Z[indexWord( 4, 0 )] != 0); + sigZ = + softfloat_add128( + sig256Z[indexWord( 4, 3 )], sig256Z[indexWord( 4, 2 )], + sigA.v64, sigA.v0 + ); + if ( UINT64_C( 0x0002000000000000 ) <= sigZ.v64 ) { + ++expZ; + sig128Extra = + softfloat_shortShiftRightJam128Extra( + sigZ.v64, sigZ.v0, sigZExtra, 1 ); + sigZ = sig128Extra.v; + sigZExtra = sig128Extra.extra; + } + return + softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infArg: + if ( ! magBits ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + goto uiZ; + } + uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 ); + goto uiZ0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ.v64 = packToF128UI64( signZ, 0, 0 ); + uiZ0: + uiZ.v0 = 0; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mulAdd.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mulAdd.c new file mode 100644 index 000000000..c7272d4e0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_mulAdd.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + union ui128_f128 uC; + uint_fast64_t uiC64, uiC0; + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + uC.f = c; + uiC64 = uC.ui.v64; + uiC0 = uC.ui.v0; + return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_rem.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_rem.c new file mode 100644 index 000000000..f525f697a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_rem.c @@ -0,0 +1,190 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t f128_rem( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool signA; + int_fast32_t expA; + struct uint128 sigA; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + int_fast32_t expB; + struct uint128 sigB; + struct exp32_sig128 normExpSig; + struct uint128 rem; + int_fast32_t expDiff; + uint_fast32_t q, recip32; + uint_fast64_t q64; + struct uint128 term, altRem, meanRem; + bool signRem; + struct uint128 uiZ; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + signA = signF128UI64( uiA64 ); + expA = expF128UI64( uiA64 ); + sigA.v64 = fracF128UI64( uiA64 ); + sigA.v0 = uiA0; + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + expB = expF128UI64( uiB64 ); + sigB.v64 = fracF128UI64( uiB64 ); + sigB.v0 = uiB0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( + (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0)) + ) { + goto propagateNaN; + } + goto invalid; + } + if ( expB == 0x7FFF ) { + if ( sigB.v64 | sigB.v0 ) goto propagateNaN; + return a; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! (sigB.v64 | sigB.v0) ) goto invalid; + normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! (sigA.v64 | sigA.v0) ) return a; + normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sigA.v64 |= UINT64_C( 0x0001000000000000 ); + sigB.v64 |= UINT64_C( 0x0001000000000000 ); + rem = sigA; + expDiff = expA - expB; + if ( expDiff < 1 ) { + if ( expDiff < -1 ) return a; + if ( expDiff ) { + --expB; + sigB = softfloat_add128( sigB.v64, sigB.v0, sigB.v64, sigB.v0 ); + q = 0; + } else { + q = softfloat_le128( sigB.v64, sigB.v0, rem.v64, rem.v0 ); + if ( q ) { + rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 ); + } + } + } else { + recip32 = softfloat_approxRecip32_1( sigB.v64>>17 ); + expDiff -= 30; + for (;;) { + q64 = (uint_fast64_t) (uint32_t) (rem.v64>>19) * recip32; + if ( expDiff < 0 ) break; + q = (q64 + 0x80000000)>>32; + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + term = softfloat_mul128By32( sigB.v64, sigB.v0, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 ); + } + expDiff -= 29; + } + /*-------------------------------------------------------------------- + | (`expDiff' cannot be less than -29 here.) + *--------------------------------------------------------------------*/ + q = (uint32_t) (q64>>32)>>(~expDiff & 31); + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, expDiff + 30 ); + term = softfloat_mul128By32( sigB.v64, sigB.v0, q ); + rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 ); + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + altRem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 ); + goto selectRem; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + do { + altRem = rem; + ++q; + rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 ); + } while ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ); + selectRem: + meanRem = softfloat_add128( rem.v64, rem.v0, altRem.v64, altRem.v0 ); + if ( + (meanRem.v64 & UINT64_C( 0x8000000000000000 )) + || (! (meanRem.v64 | meanRem.v0) && (q & 1)) + ) { + rem = altRem; + } + signRem = signA; + if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) { + signRem = ! signRem; + rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 ); + } + return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_roundToInt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_roundToInt.c new file mode 100644 index 000000000..69185d6ef --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_roundToInt.c @@ -0,0 +1,172 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t + f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + int_fast32_t exp; + struct uint128 uiZ; + uint_fast64_t lastBitMask0, roundBitsMask; + bool roundNearEven; + uint_fast64_t lastBitMask64; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + exp = expF128UI64( uiA64 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x402F <= exp ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( 0x406F <= exp ) { + if ( (exp == 0x7FFF) && (fracF128UI64( uiA64 ) | uiA0) ) { + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 ); + goto uiZ; + } + return a; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + lastBitMask0 = (uint_fast64_t) 2<<(0x406E - exp); + roundBitsMask = lastBitMask0 - 1; + uiZ.v64 = uiA64; + uiZ.v0 = uiA0; + roundNearEven = (roundingMode == softfloat_round_near_even); + if ( roundNearEven || (roundingMode == softfloat_round_near_maxMag) ) { + if ( exp == 0x402F ) { + if ( UINT64_C( 0x8000000000000000 ) <= uiZ.v0 ) { + ++uiZ.v64; + if ( + roundNearEven + && (uiZ.v0 == UINT64_C( 0x8000000000000000 )) + ) { + uiZ.v64 &= ~1; + } + } + } else { + uiZ = softfloat_add128( uiZ.v64, uiZ.v0, 0, lastBitMask0>>1 ); + if ( roundNearEven && !(uiZ.v0 & roundBitsMask) ) { + uiZ.v0 &= ~lastBitMask0; + } + } + } else if ( + roundingMode + == (signF128UI64( uiZ.v64 ) ? softfloat_round_min + : softfloat_round_max) + ) { + uiZ = softfloat_add128( uiZ.v64, uiZ.v0, 0, roundBitsMask ); + } + uiZ.v0 &= ~roundBitsMask; + lastBitMask64 = !lastBitMask0; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( exp < 0x3FFF ) { + if ( !((uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF )) | uiA0) ) return a; + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + uiZ.v64 = uiA64 & packToF128UI64( 1, 0, 0 ); + uiZ.v0 = 0; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( !(fracF128UI64( uiA64 ) | uiA0) ) break; + case softfloat_round_near_maxMag: + if ( exp == 0x3FFE ) uiZ.v64 |= packToF128UI64( 0, 0x3FFF, 0 ); + break; + case softfloat_round_min: + if ( uiZ.v64 ) uiZ.v64 = packToF128UI64( 1, 0x3FFF, 0 ); + break; + case softfloat_round_max: + if ( !uiZ.v64 ) uiZ.v64 = packToF128UI64( 0, 0x3FFF, 0 ); + break; +#ifdef SOFTFLOAT_ROUND_ODD + case softfloat_round_odd: + uiZ.v64 |= packToF128UI64( 0, 0x3FFF, 0 ); + break; +#endif + } + goto uiZ; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + uiZ.v64 = uiA64; + uiZ.v0 = 0; + lastBitMask64 = (uint_fast64_t) 1<<(0x402F - exp); + roundBitsMask = lastBitMask64 - 1; + if ( roundingMode == softfloat_round_near_maxMag ) { + uiZ.v64 += lastBitMask64>>1; + } else if ( roundingMode == softfloat_round_near_even ) { + uiZ.v64 += lastBitMask64>>1; + if ( !((uiZ.v64 & roundBitsMask) | uiA0) ) { + uiZ.v64 &= ~lastBitMask64; + } + } else if ( + roundingMode + == (signF128UI64( uiZ.v64 ) ? softfloat_round_min + : softfloat_round_max) + ) { + uiZ.v64 = (uiZ.v64 | (uiA0 != 0)) + roundBitsMask; + } + uiZ.v64 &= ~roundBitsMask; + lastBitMask0 = 0; + } + if ( (uiZ.v64 != uiA64) || (uiZ.v0 != uiA0) ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + uiZ.v64 |= lastBitMask64; + uiZ.v0 |= lastBitMask0; + } +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sqrt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sqrt.c new file mode 100644 index 000000000..f1d9bac79 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sqrt.c @@ -0,0 +1,201 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t f128_sqrt( float128_t a ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool signA; + int_fast32_t expA; + struct uint128 sigA, uiZ; + struct exp32_sig128 normExpSig; + int_fast32_t expZ; + uint_fast32_t sig32A, recipSqrt32, sig32Z; + struct uint128 rem; + uint32_t qs[3]; + uint_fast32_t q; + uint_fast64_t x64, sig64Z; + struct uint128 y, term; + uint_fast64_t sigZExtra; + struct uint128 sigZ; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + signA = signF128UI64( uiA64 ); + expA = expF128UI64( uiA64 ); + sigA.v64 = fracF128UI64( uiA64 ); + sigA.v0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( sigA.v64 | sigA.v0 ) { + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 ); + goto uiZ; + } + if ( ! signA ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signA ) { + if ( ! (expA | sigA.v64 | sigA.v0) ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! (sigA.v64 | sigA.v0) ) return a; + normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + | (`sig32Z' is guaranteed to be a lower bound on the square root of + | `sig32A', which makes `sig32Z' also a lower bound on the square root of + | `sigA'.) + *------------------------------------------------------------------------*/ + expZ = ((expA - 0x3FFF)>>1) + 0x3FFE; + expA &= 1; + sigA.v64 |= UINT64_C( 0x0001000000000000 ); + sig32A = sigA.v64>>17; + recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A ); + sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32; + if ( expA ) { + sig32Z >>= 1; + rem = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 12 ); + } else { + rem = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 13 ); + } + qs[2] = sig32Z; + rem.v64 -= (uint_fast64_t) sig32Z * sig32Z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = ((uint32_t) (rem.v64>>2) * (uint_fast64_t) recipSqrt32)>>32; + x64 = (uint_fast64_t) sig32Z<<32; + sig64Z = x64 + ((uint_fast64_t) q<<3); + y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + /*------------------------------------------------------------------------ + | (Repeating this loop is a rare occurrence.) + *------------------------------------------------------------------------*/ + for (;;) { + term = softfloat_mul64ByShifted32To128( x64 + sig64Z, q ); + rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 ); + if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break; + --q; + sig64Z -= 1<<3; + } + qs[1] = q; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = ((rem.v64>>2) * recipSqrt32)>>32; + y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 ); + sig64Z <<= 1; + /*------------------------------------------------------------------------ + | (Repeating this loop is a rare occurrence.) + *------------------------------------------------------------------------*/ + for (;;) { + term = softfloat_shortShiftLeft128( 0, sig64Z, 32 ); + term = softfloat_add128( term.v64, term.v0, 0, (uint_fast64_t) q<<6 ); + term = softfloat_mul128By32( term.v64, term.v0, q ); + rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 ); + if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break; + --q; + } + qs[0] = q; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + q = (((rem.v64>>2) * recipSqrt32)>>32) + 2; + sigZExtra = (uint64_t) ((uint_fast64_t) q<<59); + term = softfloat_shortShiftLeft128( 0, qs[1], 53 ); + sigZ = + softfloat_add128( + (uint_fast64_t) qs[2]<<18, ((uint_fast64_t) qs[0]<<24) + (q>>5), + term.v64, term.v0 + ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (q & 0xF) <= 2 ) { + q &= ~3; + sigZExtra = (uint64_t) ((uint_fast64_t) q<<59); + y = softfloat_shortShiftLeft128( sigZ.v64, sigZ.v0, 6 ); + y.v0 |= sigZExtra>>58; + term = softfloat_sub128( y.v64, y.v0, 0, q ); + y = softfloat_mul64ByShifted32To128( term.v0, q ); + term = softfloat_mul64ByShifted32To128( term.v64, q ); + term = softfloat_add128( term.v64, term.v0, 0, y.v64 ); + rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 20 ); + term = softfloat_sub128( term.v64, term.v0, rem.v64, rem.v0 ); + /*-------------------------------------------------------------------- + | The concatenation of `term' and `y.v0' is now the negative remainder + | (3 words altogether). + *--------------------------------------------------------------------*/ + if ( term.v64 & UINT64_C( 0x8000000000000000 ) ) { + sigZExtra |= 1; + } else { + if ( term.v64 | term.v0 | y.v0 ) { + if ( sigZExtra ) { + --sigZExtra; + } else { + sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, 0, 1 ); + sigZExtra = ~0; + } + } + } + } + return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sub.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sub.c new file mode 100644 index 000000000..5181cc5ec --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_sub.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t f128_sub( float128_t a, float128_t b ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool signA; + union ui128_f128 uB; + uint_fast64_t uiB64, uiB0; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + float128_t + (*magsFuncPtr)( + uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); +#endif + + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + signA = signF128UI64( uiA64 ); + uB.f = b; + uiB64 = uB.ui.v64; + uiB0 = uB.ui.v0; + signB = signF128UI64( uiB64 ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } else { + return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128; + return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_extF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_extF80.c new file mode 100644 index 000000000..ec169c0ff --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_extF80.c @@ -0,0 +1,109 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t f128_to_extF80( float128_t a ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t frac64, frac0; + struct commonNaN commonNaN; + struct uint128 uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + struct exp32_sig128 normExpSig; + struct uint128 sig128; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + frac64 = fracF128UI64( uiA64 ); + frac0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( frac64 | frac0 ) { + softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToExtF80UI( &commonNaN ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + } else { + uiZ64 = packToExtF80UI64( sign, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! (frac64 | frac0) ) { + uiZ64 = packToExtF80UI64( sign, 0 ); + uiZ0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF128Sig( frac64, frac0 ); + exp = normExpSig.exp; + frac64 = normExpSig.sig.v64; + frac0 = normExpSig.sig.v0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig128 = + softfloat_shortShiftLeft128( + frac64 | UINT64_C( 0x0001000000000000 ), frac0, 15 ); + return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f16.c new file mode 100644 index 000000000..5a8ee7212 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f16.c @@ -0,0 +1,95 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t f128_to_f16( float128_t a ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t frac64; + struct commonNaN commonNaN; + uint_fast16_t uiZ, frac16; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + frac64 = fracF128UI64( uiA64 ) | (uiA0 != 0); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( frac64 ) { + softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToF16UI( &commonNaN ); + } else { + uiZ = packToF16UI( sign, 0x1F, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac16 = softfloat_shortShiftRightJam64( frac64, 34 ); + if ( ! (exp | frac16) ) { + uiZ = packToF16UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3FF1; + if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) { + if ( exp < -0x40 ) exp = -0x40; + } + return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f32.c new file mode 100644 index 000000000..07e4a80df --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f32.c @@ -0,0 +1,95 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f128_to_f32( float128_t a ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t frac64; + struct commonNaN commonNaN; + uint_fast32_t uiZ, frac32; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + frac64 = fracF128UI64( uiA64 ) | (uiA0 != 0); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( frac64 ) { + softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToF32UI( &commonNaN ); + } else { + uiZ = packToF32UI( sign, 0xFF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac32 = softfloat_shortShiftRightJam64( frac64, 18 ); + if ( ! (exp | frac32) ) { + uiZ = packToF32UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3F81; + if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f64.c new file mode 100644 index 000000000..f791938b4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_f64.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f128_to_f64( float128_t a ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t frac64, frac0; + struct commonNaN commonNaN; + uint_fast64_t uiZ; + struct uint128 frac128; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + frac64 = fracF128UI64( uiA64 ); + frac0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FFF ) { + if ( frac64 | frac0 ) { + softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN ); + uiZ = softfloat_commonNaNToF64UI( &commonNaN ); + } else { + uiZ = packToF64UI( sign, 0x7FF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac128 = softfloat_shortShiftLeft128( frac64, frac0, 14 ); + frac64 = frac128.v64 | (frac128.v0 != 0); + if ( ! (exp | frac64) ) { + uiZ = packToF64UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + exp -= 0x3C01; + if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) { + if ( exp < -0x1000 ) exp = -0x1000; + } + return + softfloat_roundPackToF64( + sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32.c new file mode 100644 index 000000000..16c4a3ccd --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32.c @@ -0,0 +1,85 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig64, sig0; + int_fast32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ); + sig0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow) + if ( (exp == 0x7FFF) && (sig64 | sig0) ) { +#if (i32_fromNaN == i32_fromPosOverflow) + sign = 0; +#elif (i32_fromNaN == i32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return i32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 ); + sig64 |= (sig0 != 0); + shiftDist = 0x4023 - exp; + if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist ); + return softfloat_roundToI32( sign, sig64, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32_r_minMag.c new file mode 100644 index 000000000..18cfeaee5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i32_r_minMag.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + int_fast32_t exp; + uint_fast64_t sig64; + int_fast32_t shiftDist; + bool sign; + int_fast32_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x402F - exp; + if ( 49 <= shiftDist ) { + if ( exact && (exp | sig64) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF128UI64( uiA64 ); + if ( shiftDist < 18 ) { + if ( + sign && (shiftDist == 17) + && (sig64 < UINT64_C( 0x0000000000020000 )) + ) { + if ( exact && sig64 ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return -0x7FFFFFFF - 1; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && sig64 ? i32_fromNaN + : sign ? i32_fromNegOverflow : i32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig64 |= UINT64_C( 0x0001000000000000 ); + absZ = sig64>>shiftDist; + if ( + exact && ((uint_fast64_t) (uint_fast32_t) absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig64, sig0; + int_fast32_t shiftDist; + struct uint128 sig128; + struct uint64_extra sigExtra; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ); + sig0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x402F - exp; + if ( shiftDist <= 0 ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( shiftDist < -15 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig64 |= UINT64_C( 0x0001000000000000 ); + if ( shiftDist ) { + sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftDist ); + sig64 = sig128.v64; + sig0 = sig128.v0; + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 ); + sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftDist ); + sig64 = sigExtra.v; + sig0 = sigExtra.extra; + } + return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i64_r_minMag.c new file mode 100644 index 000000000..e2cc62e27 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_i64_r_minMag.c @@ -0,0 +1,113 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig64, sig0; + int_fast32_t shiftDist; + int_fast8_t negShiftDist; + int_fast64_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ); + sig0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x402F - exp; + if ( shiftDist < 0 ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( shiftDist < -14 ) { + if ( + (uiA64 == UINT64_C( 0xC03E000000000000 )) + && (sig0 < UINT64_C( 0x0002000000000000 )) + ) { + if ( exact && sig0 ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig64 |= UINT64_C( 0x0001000000000000 ); + negShiftDist = -shiftDist; + absZ = sig64<>(shiftDist & 63); + if ( exact && (uint64_t) (sig0<>shiftDist; + if ( exact && (sig0 || (absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t + f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig64; + int_fast32_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow) + if ( (exp == 0x7FFF) && sig64 ) { +#if (ui32_fromNaN == ui32_fromPosOverflow) + sign = 0; +#elif (ui32_fromNaN == ui32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return ui32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 ); + shiftDist = 0x4023 - exp; + if ( 0 < shiftDist ) { + sig64 = softfloat_shiftRightJam64( sig64, shiftDist ); + } + return softfloat_roundToUI32( sign, sig64, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui32_r_minMag.c new file mode 100644 index 000000000..92facd517 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui32_r_minMag.c @@ -0,0 +1,89 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + int_fast32_t exp; + uint_fast64_t sig64; + int_fast32_t shiftDist; + bool sign; + uint_fast32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x402F - exp; + if ( 49 <= shiftDist ) { + if ( exact && (exp | sig64) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF128UI64( uiA64 ); + if ( sign || (shiftDist < 17) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && sig64 ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig64 |= UINT64_C( 0x0001000000000000 ); + z = sig64>>shiftDist; + if ( exact && ((uint_fast64_t) z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t + f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig64, sig0; + int_fast32_t shiftDist; + struct uint128 sig128; + struct uint64_extra sigExtra; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ); + sig0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x402F - exp; + if ( shiftDist <= 0 ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( shiftDist < -15 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig64 |= UINT64_C( 0x0001000000000000 ); + if ( shiftDist ) { + sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftDist ); + sig64 = sig128.v64; + sig0 = sig128.v0; + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 ); + sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftDist ); + sig64 = sigExtra.v; + sig0 = sigExtra.extra; + } + return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui64_r_minMag.c new file mode 100644 index 000000000..edeafd3c8 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f128_to_ui64_r_minMag.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact ) +{ + union ui128_f128 uA; + uint_fast64_t uiA64, uiA0; + bool sign; + int_fast32_t exp; + uint_fast64_t sig64, sig0; + int_fast32_t shiftDist; + int_fast8_t negShiftDist; + uint_fast64_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA64 = uA.ui.v64; + uiA0 = uA.ui.v0; + sign = signF128UI64( uiA64 ); + exp = expF128UI64( uiA64 ); + sig64 = fracF128UI64( uiA64 ); + sig0 = uiA0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x402F - exp; + if ( shiftDist < 0 ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( sign || (shiftDist < -15) ) goto invalid; + sig64 |= UINT64_C( 0x0001000000000000 ); + negShiftDist = -shiftDist; + z = sig64<>(shiftDist & 63); + if ( exact && (uint64_t) (sig0<>shiftDist; + if ( exact && (sig0 || (z< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t f16_add( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1) + float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t ); +#endif + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; +#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL) + if ( signF16UI( uiA ^ uiB ) ) { + return softfloat_subMagsF16( uiA, uiB ); + } else { + return softfloat_addMagsF16( uiA, uiB ); + } +#else + magsFuncPtr = + signF16UI( uiA ^ uiB ) ? softfloat_subMagsF16 : softfloat_addMagsF16; + return (*magsFuncPtr)( uiA, uiB ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_div.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_div.c new file mode 100644 index 000000000..77f9a2cd2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_div.c @@ -0,0 +1,186 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extern const uint16_t softfloat_approxRecip_1k0s[]; +extern const uint16_t softfloat_approxRecip_1k1s[]; + +float16_t f16_div( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool signA; + int_fast8_t expA; + uint_fast16_t sigA; + union ui16_f16 uB; + uint_fast16_t uiB; + bool signB; + int_fast8_t expB; + uint_fast16_t sigB; + bool signZ; + struct exp8_sig16 normExpSig; + int_fast8_t expZ; +#ifdef SOFTFLOAT_FAST_DIV32TO16 + uint_fast32_t sig32A; + uint_fast16_t sigZ; +#else + int index; + uint16_t r0; + uint_fast16_t sigZ, rem; +#endif + uint_fast16_t uiZ; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF16UI( uiA ); + expA = expF16UI( uiA ); + sigA = fracF16UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF16UI( uiB ); + expB = expF16UI( uiB ); + sigB = fracF16UI( uiB ); + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x1F ) { + if ( sigA ) goto propagateNaN; + if ( expB == 0x1F ) { + if ( sigB ) goto propagateNaN; + goto invalid; + } + goto infinity; + } + if ( expB == 0x1F ) { + if ( sigB ) goto propagateNaN; + goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! sigB ) { + if ( ! (expA | sigA) ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinite ); + goto infinity; + } + normExpSig = softfloat_normSubnormalF16Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF16Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA - expB + 0xE; + sigA |= 0x0400; + sigB |= 0x0400; +#ifdef SOFTFLOAT_FAST_DIV32TO16 + if ( sigA < sigB ) { + --expZ; + sig32A = (uint_fast32_t) sigA<<15; + } else { + sig32A = (uint_fast32_t) sigA<<14; + } + sigZ = sig32A / sigB; + if ( ! (sigZ & 7) ) sigZ |= ((uint_fast32_t) sigB * sigZ != sig32A); +#else + if ( sigA < sigB ) { + --expZ; + sigA <<= 5; + } else { + sigA <<= 4; + } + index = sigB>>6 & 0xF; + r0 = softfloat_approxRecip_1k0s[index] + - (((uint_fast32_t) softfloat_approxRecip_1k1s[index] + * (sigB & 0x3F)) + >>10); + sigZ = ((uint_fast32_t) sigA * r0)>>16; + rem = (sigA<<10) - sigZ * sigB; + sigZ += (rem * (uint_fast32_t) r0)>>26; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + ++sigZ; + if ( ! (sigZ & 7) ) { + sigZ &= ~1; + rem = (sigA<<10) - sigZ * sigB; + if ( rem & 0x8000 ) { + sigZ -= 2; + } else { + if ( rem ) sigZ |= 1; + } + } +#endif + return softfloat_roundPackToF16( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF16UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF16UI; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infinity: + uiZ = packToF16UI( signZ, 0x1F, 0 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ = packToF16UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq.c new file mode 100644 index 000000000..692fa035f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f16_eq( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) { + if ( + softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + return (uiA == uiB) || ! (uint16_t) ((uiA | uiB)<<1); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq_signaling.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq_signaling.c new file mode 100644 index 000000000..c1e7a509c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_eq_signaling.c @@ -0,0 +1,61 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f16_eq_signaling( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + return (uiA == uiB) || ! (uint16_t) ((uiA | uiB)<<1); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_isSignalingNaN.c new file mode 100644 index 000000000..3eb3d4cc6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_isSignalingNaN.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f16_isSignalingNaN( float16_t a ) +{ + union ui16_f16 uA; + + uA.f = a; + return softfloat_isSigNaNF16UI( uA.ui ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le.c new file mode 100644 index 000000000..d7313debd --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f16_le( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF16UI( uiA ); + signB = signF16UI( uiB ); + return + (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1) + : (uiA == uiB) || (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le_quiet.c new file mode 100644 index 000000000..15181c260 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_le_quiet.c @@ -0,0 +1,71 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f16_le_quiet( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) { + if ( + softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF16UI( uiA ); + signB = signF16UI( uiB ); + return + (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1) + : (uiA == uiB) || (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt.c new file mode 100644 index 000000000..7745699a2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f16_lt( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF16UI( uiA ); + signB = signF16UI( uiB ); + return + (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0) + : (uiA != uiB) && (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt_quiet.c new file mode 100644 index 000000000..a31e4a13f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_lt_quiet.c @@ -0,0 +1,71 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f16_lt_quiet( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) { + if ( + softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF16UI( uiA ); + signB = signF16UI( uiB ); + return + (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0) + : (uiA != uiB) && (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mul.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mul.c new file mode 100644 index 000000000..a47cab8ce --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mul.c @@ -0,0 +1,140 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t f16_mul( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool signA; + int_fast8_t expA; + uint_fast16_t sigA; + union ui16_f16 uB; + uint_fast16_t uiB; + bool signB; + int_fast8_t expB; + uint_fast16_t sigB; + bool signZ; + uint_fast16_t magBits; + struct exp8_sig16 normExpSig; + int_fast8_t expZ; + uint_fast32_t sig32Z; + uint_fast16_t sigZ, uiZ; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF16UI( uiA ); + expA = expF16UI( uiA ); + sigA = fracF16UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF16UI( uiB ); + expB = expF16UI( uiB ); + sigB = fracF16UI( uiB ); + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x1F ) { + if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN; + magBits = expB | sigB; + goto infArg; + } + if ( expB == 0x1F ) { + if ( sigB ) goto propagateNaN; + magBits = expA | sigA; + goto infArg; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF16Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zero; + normExpSig = softfloat_normSubnormalF16Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0xF; + sigA = (sigA | 0x0400)<<4; + sigB = (sigB | 0x0400)<<5; + sig32Z = (uint_fast32_t) sigA * sigB; + sigZ = sig32Z>>16; + if ( sig32Z & 0xFFFF ) sigZ |= 1; + if ( sigZ < 0x4000 ) { + --expZ; + sigZ <<= 1; + } + return softfloat_roundPackToF16( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF16UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infArg: + if ( ! magBits ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF16UI; + } else { + uiZ = packToF16UI( signZ, 0x1F, 0 ); + } + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ = packToF16UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mulAdd.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mulAdd.c new file mode 100644 index 000000000..e97571ac5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_mulAdd.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; + union ui16_f16 uC; + uint_fast16_t uiC; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + uC.f = c; + uiC = uC.ui; + return softfloat_mulAddF16( uiA, uiB, uiC, 0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_rem.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_rem.c new file mode 100644 index 000000000..0ffa498a1 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_rem.c @@ -0,0 +1,171 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t f16_rem( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool signA; + int_fast8_t expA; + uint_fast16_t sigA; + union ui16_f16 uB; + uint_fast16_t uiB; + int_fast8_t expB; + uint_fast16_t sigB; + struct exp8_sig16 normExpSig; + uint16_t rem; + int_fast8_t expDiff; + uint_fast16_t q; + uint32_t recip32, q32; + uint16_t altRem, meanRem; + bool signRem; + uint_fast16_t uiZ; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF16UI( uiA ); + expA = expF16UI( uiA ); + sigA = fracF16UI( uiA ); + uB.f = b; + uiB = uB.ui; + expB = expF16UI( uiB ); + sigB = fracF16UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x1F ) { + if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN; + goto invalid; + } + if ( expB == 0x1F ) { + if ( sigB ) goto propagateNaN; + return a; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! sigB ) goto invalid; + normExpSig = softfloat_normSubnormalF16Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF16Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + rem = sigA | 0x0400; + sigB |= 0x0400; + expDiff = expA - expB; + if ( expDiff < 1 ) { + if ( expDiff < -1 ) return a; + sigB <<= 3; + if ( expDiff ) { + rem <<= 2; + q = 0; + } else { + rem <<= 3; + q = (sigB <= rem); + if ( q ) rem -= sigB; + } + } else { + recip32 = softfloat_approxRecip32_1( (uint_fast32_t) sigB<<21 ); + /*-------------------------------------------------------------------- + | Changing the shift of `rem' here requires also changing the initial + | subtraction from `expDiff'. + *--------------------------------------------------------------------*/ + rem <<= 4; + expDiff -= 31; + /*-------------------------------------------------------------------- + | The scale of `sigB' affects how many bits are obtained during each + | cycle of the loop. Currently this is 29 bits per loop iteration, + | which is believed to be the maximum possible. + *--------------------------------------------------------------------*/ + sigB <<= 3; + for (;;) { + q32 = (rem * (uint_fast64_t) recip32)>>16; + if ( expDiff < 0 ) break; + rem = -((uint_fast16_t) q32 * sigB); + expDiff -= 29; + } + /*-------------------------------------------------------------------- + | (`expDiff' cannot be less than -30 here.) + *--------------------------------------------------------------------*/ + q32 >>= ~expDiff & 31; + q = q32; + rem = (rem<<(expDiff + 30)) - q * sigB; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + do { + altRem = rem; + ++q; + rem -= sigB; + } while ( ! (rem & 0x8000) ); + meanRem = rem + altRem; + if ( (meanRem & 0x8000) || (! meanRem && (q & 1)) ) rem = altRem; + signRem = signA; + if ( 0x8000 <= rem ) { + signRem = ! signRem; + rem = -rem; + } + return softfloat_normRoundPackToF16( signRem, expB, rem ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF16UI( uiA, uiB ); + goto uiZ; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF16UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_roundToInt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_roundToInt.c new file mode 100644 index 000000000..a567d51d9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_roundToInt.c @@ -0,0 +1,120 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + int_fast8_t exp; + uint_fast16_t uiZ, lastBitMask, roundBitsMask; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp <= 0xE ) { + if ( !(uint16_t) (uiA<<1) ) return a; + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + uiZ = uiA & packToF16UI( 1, 0, 0 ); + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( !fracF16UI( uiA ) ) break; + case softfloat_round_near_maxMag: + if ( exp == 0xE ) uiZ |= packToF16UI( 0, 0xF, 0 ); + break; + case softfloat_round_min: + if ( uiZ ) uiZ = packToF16UI( 1, 0xF, 0 ); + break; + case softfloat_round_max: + if ( !uiZ ) uiZ = packToF16UI( 0, 0xF, 0 ); + break; +#ifdef SOFTFLOAT_ROUND_ODD + case softfloat_round_odd: + uiZ |= packToF16UI( 0, 0xF, 0 ); + break; +#endif + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x19 <= exp ) { + if ( (exp == 0x1F) && fracF16UI( uiA ) ) { + uiZ = softfloat_propagateNaNF16UI( uiA, 0 ); + goto uiZ; + } + return a; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ = uiA; + lastBitMask = (uint_fast16_t) 1<<(0x19 - exp); + roundBitsMask = lastBitMask - 1; + if ( roundingMode == softfloat_round_near_maxMag ) { + uiZ += lastBitMask>>1; + } else if ( roundingMode == softfloat_round_near_even ) { + uiZ += lastBitMask>>1; + if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask; + } else if ( + roundingMode + == (signF16UI( uiZ ) ? softfloat_round_min : softfloat_round_max) + ) { + uiZ += roundBitsMask; + } + uiZ &= ~roundBitsMask; + if ( uiZ != uiA ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sqrt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sqrt.c new file mode 100644 index 000000000..47a3bbf14 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sqrt.c @@ -0,0 +1,136 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extern const uint16_t softfloat_approxRecipSqrt_1k0s[]; +extern const uint16_t softfloat_approxRecipSqrt_1k1s[]; + +float16_t f16_sqrt( float16_t a ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool signA; + int_fast8_t expA; + uint_fast16_t sigA, uiZ; + struct exp8_sig16 normExpSig; + int_fast8_t expZ; + int index; + uint_fast16_t r0; + uint_fast32_t ESqrR0; + uint16_t sigma0; + uint_fast16_t recipSqrt16, sigZ, shiftedSigZ; + uint16_t negRem; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF16UI( uiA ); + expA = expF16UI( uiA ); + sigA = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x1F ) { + if ( sigA ) { + uiZ = softfloat_propagateNaNF16UI( uiA, 0 ); + goto uiZ; + } + if ( ! signA ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signA ) { + if ( ! (expA | sigA) ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF16Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = ((expA - 0xF)>>1) + 0xE; + expA &= 1; + sigA |= 0x0400; + index = (sigA>>6 & 0xE) + expA; + r0 = softfloat_approxRecipSqrt_1k0s[index] + - (((uint_fast32_t) softfloat_approxRecipSqrt_1k1s[index] + * (sigA & 0x7F)) + >>11); + ESqrR0 = ((uint_fast32_t) r0 * r0)>>1; + if ( expA ) ESqrR0 >>= 1; + sigma0 = ~(uint_fast16_t) ((ESqrR0 * sigA)>>16); + recipSqrt16 = r0 + (((uint_fast32_t) r0 * sigma0)>>25); + if ( ! (recipSqrt16 & 0x8000) ) recipSqrt16 = 0x8000; + sigZ = ((uint_fast32_t) (sigA<<5) * recipSqrt16)>>16; + if ( expA ) sigZ >>= 1; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + ++sigZ; + if ( ! (sigZ & 7) ) { + shiftedSigZ = sigZ>>1; + negRem = shiftedSigZ * shiftedSigZ; + sigZ &= ~1; + if ( negRem & 0x8000 ) { + sigZ |= 1; + } else { + if ( negRem ) --sigZ; + } + } + return softfloat_roundPackToF16( 0, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF16UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sub.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sub.c new file mode 100644 index 000000000..03a87cf32 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_sub.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t f16_sub( float16_t a, float16_t b ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + union ui16_f16 uB; + uint_fast16_t uiB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1) + float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t ); +#endif + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; +#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL) + if ( signF16UI( uiA ^ uiB ) ) { + return softfloat_addMagsF16( uiA, uiB ); + } else { + return softfloat_subMagsF16( uiA, uiB ); + } +#else + magsFuncPtr = + signF16UI( uiA ^ uiB ) ? softfloat_addMagsF16 : softfloat_subMagsF16; + return (*magsFuncPtr)( uiA, uiB ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80.c new file mode 100644 index 000000000..99c2dfc74 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t f16_to_extF80( float16_t a ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + struct commonNaN commonNaN; + struct uint128 uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + struct exp8_sig16 normExpSig; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + if ( frac ) { + softfloat_f16UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToExtF80UI( &commonNaN ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + } else { + uiZ64 = packToExtF80UI64( sign, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ64 = packToExtF80UI64( sign, 0 ); + uiZ0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF16Sig( frac ); + exp = normExpSig.exp; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 ); + uiZ0 = (uint_fast64_t) (frac | 0x0400)<<53; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80M.c new file mode 100644 index 000000000..7f2d53458 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_extF80M.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f16_to_extF80M( float16_t a, extFloat80_t *zPtr ) +{ + + *zPtr = f16_to_extF80( a ); + +} + +#else + +void f16_to_extF80M( float16_t a, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + union ui16_f16 uA; + uint16_t uiA; + bool sign; + int_fast8_t exp; + uint16_t frac; + struct commonNaN commonNaN; + uint_fast16_t uiZ64; + uint32_t uiZ32; + struct exp8_sig16 normExpSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zSPtr = (struct extFloat80M *) zPtr; + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + if ( frac ) { + softfloat_f16UIToCommonNaN( uiA, &commonNaN ); + softfloat_commonNaNToExtF80M( &commonNaN, zSPtr ); + return; + } + uiZ64 = packToExtF80UI64( sign, 0x7FFF ); + uiZ32 = 0x80000000; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ64 = packToExtF80UI64( sign, 0 ); + uiZ32 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF16Sig( frac ); + exp = normExpSig.exp; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 ); + uiZ32 = 0x80000000 | (uint32_t) frac<<21; + uiZ: + zSPtr->signExp = uiZ64; + zSPtr->signif = (uint64_t) uiZ32<<32; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128.c new file mode 100644 index 000000000..c4b81dc84 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t f16_to_f128( float16_t a ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + struct commonNaN commonNaN; + struct uint128 uiZ; + struct exp8_sig16 normExpSig; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + if ( frac ) { + softfloat_f16UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF128UI( &commonNaN ); + } else { + uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 ); + uiZ.v0 = 0; + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ.v64 = packToF128UI64( sign, 0, 0 ); + uiZ.v0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF16Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ.v64 = packToF128UI64( sign, exp + 0x3FF0, (uint_fast64_t) frac<<38 ); + uiZ.v0 = 0; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128M.c new file mode 100644 index 000000000..b4fc873b5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f128M.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f16_to_f128M( float16_t a, float128_t *zPtr ) +{ + + *zPtr = f16_to_f128( a ); + +} + +#else + +void f16_to_f128M( float16_t a, float128_t *zPtr ) +{ + uint32_t *zWPtr; + union ui16_f16 uA; + uint16_t uiA; + bool sign; + int_fast8_t exp; + uint16_t frac; + struct commonNaN commonNaN; + uint32_t uiZ96; + struct exp8_sig16 normExpSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + if ( frac ) { + softfloat_f16UIToCommonNaN( uiA, &commonNaN ); + softfloat_commonNaNToF128M( &commonNaN, zWPtr ); + return; + } + uiZ96 = packToF128UI96( sign, 0x7FFF, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ96 = packToF128UI96( sign, 0, 0 ); + goto uiZ; + } + normExpSig = softfloat_normSubnormalF16Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ96 = packToF128UI96( sign, exp + 0x3FF0, (uint32_t) frac<<6 ); + uiZ: + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f32.c new file mode 100644 index 000000000..a219454bf --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f32.c @@ -0,0 +1,93 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f16_to_f32( float16_t a ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + struct commonNaN commonNaN; + uint_fast32_t uiZ; + struct exp8_sig16 normExpSig; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + if ( frac ) { + softfloat_f16UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF32UI( &commonNaN ); + } else { + uiZ = packToF32UI( sign, 0xFF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ = packToF32UI( sign, 0, 0 ); + goto uiZ; + } + normExpSig = softfloat_normSubnormalF16Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ = packToF32UI( sign, exp + 0x70, (uint_fast32_t) frac<<13 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f64.c new file mode 100644 index 000000000..7e87c25f4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_f64.c @@ -0,0 +1,93 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f16_to_f64( float16_t a ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + struct commonNaN commonNaN; + uint_fast64_t uiZ; + struct exp8_sig16 normExpSig; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + if ( frac ) { + softfloat_f16UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF64UI( &commonNaN ); + } else { + uiZ = packToF64UI( sign, 0x7FF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ = packToF64UI( sign, 0, 0 ); + goto uiZ; + } + normExpSig = softfloat_normSubnormalF16Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ = packToF64UI( sign, exp + 0x3F0, (uint_fast64_t) frac<<42 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32.c new file mode 100644 index 000000000..805c4e550 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32.c @@ -0,0 +1,87 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + int_fast32_t sig32; + int_fast8_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + frac ? i32_fromNaN + : sign ? i32_fromNegOverflow : i32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig32 = frac; + if ( exp ) { + sig32 |= 0x0400; + shiftDist = exp - 0x19; + if ( 0 <= shiftDist ) { + sig32 <<= shiftDist; + return sign ? -sig32 : sig32; + } + shiftDist = exp - 0x0D; + if ( 0 < shiftDist ) sig32 <<= shiftDist; + } + return + softfloat_roundToI32( + sign, (uint_fast32_t) sig32, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32_r_minMag.c new file mode 100644 index 000000000..b1f996371 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i32_r_minMag.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + int_fast8_t exp; + uint_fast16_t frac; + int_fast8_t shiftDist; + bool sign; + int_fast32_t alignedSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = exp - 0x0F; + if ( shiftDist < 0 ) { + if ( exact && (exp | frac) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF16UI( uiA ); + if ( exp == 0x1F ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x1F) && frac ? i32_fromNaN + : sign ? i32_fromNegOverflow : i32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + alignedSig = (int_fast32_t) (frac | 0x0400)<>= 10; + return sign ? -alignedSig : alignedSig; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64.c new file mode 100644 index 000000000..e3c0065f6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64.c @@ -0,0 +1,87 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + int_fast32_t sig32; + int_fast8_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + frac ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig32 = frac; + if ( exp ) { + sig32 |= 0x0400; + shiftDist = exp - 0x19; + if ( 0 <= shiftDist ) { + sig32 <<= shiftDist; + return sign ? -sig32 : sig32; + } + shiftDist = exp - 0x0D; + if ( 0 < shiftDist ) sig32 <<= shiftDist; + } + return + softfloat_roundToI32( + sign, (uint_fast32_t) sig32, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64_r_minMag.c new file mode 100644 index 000000000..a5a6a077e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_i64_r_minMag.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + int_fast8_t exp; + uint_fast16_t frac; + int_fast8_t shiftDist; + bool sign; + int_fast32_t alignedSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = exp - 0x0F; + if ( shiftDist < 0 ) { + if ( exact && (exp | frac) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF16UI( uiA ); + if ( exp == 0x1F ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x1F) && frac ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + alignedSig = (int_fast32_t) (frac | 0x0400)<>= 10; + return sign ? -alignedSig : alignedSig; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui32.c new file mode 100644 index 000000000..5371ca339 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui32.c @@ -0,0 +1,84 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + uint_fast32_t sig32; + int_fast8_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + frac ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig32 = frac; + if ( exp ) { + sig32 |= 0x0400; + shiftDist = exp - 0x19; + if ( (0 <= shiftDist) && ! sign ) { + return sig32< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + int_fast8_t exp; + uint_fast16_t frac; + int_fast8_t shiftDist; + bool sign; + uint_fast32_t alignedSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = exp - 0x0F; + if ( shiftDist < 0 ) { + if ( exact && (exp | frac) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF16UI( uiA ); + if ( sign || (exp == 0x1F) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x1F) && frac ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + alignedSig = (uint_fast32_t) (frac | 0x0400)<>10; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64.c new file mode 100644 index 000000000..e6cb000f1 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + bool sign; + int_fast8_t exp; + uint_fast16_t frac; + uint_fast32_t sig32; + int_fast8_t shiftDist; +#ifndef SOFTFLOAT_FAST_INT64 + uint32_t extSig[3]; +#endif + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF16UI( uiA ); + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x1F ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + frac ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig32 = frac; + if ( exp ) { + sig32 |= 0x0400; + shiftDist = exp - 0x19; + if ( (0 <= shiftDist) && ! sign ) { + return sig32<>12, (uint_fast64_t) sig32<<52, roundingMode, exact ); +#else + extSig[indexWord( 3, 2 )] = 0; + extSig[indexWord( 3, 1 )] = sig32>>12; + extSig[indexWord( 3, 0 )] = sig32<<20; + return softfloat_roundMToUI64( sign, extSig, roundingMode, exact ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64_r_minMag.c new file mode 100644 index 000000000..b4f975f83 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f16_to_ui64_r_minMag.c @@ -0,0 +1,87 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + int_fast8_t exp; + uint_fast16_t frac; + int_fast8_t shiftDist; + bool sign; + uint_fast32_t alignedSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF16UI( uiA ); + frac = fracF16UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = exp - 0x0F; + if ( shiftDist < 0 ) { + if ( exact && (exp | frac) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF16UI( uiA ); + if ( sign || (exp == 0x1F) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x1F) && frac ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + alignedSig = (uint_fast32_t) (frac | 0x0400)<>10; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_add.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_add.c new file mode 100644 index 000000000..70e03e7f9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_add.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t f32_add( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1) + float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t ); +#endif + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; +#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL) + if ( signF32UI( uiA ^ uiB ) ) { + return softfloat_subMagsF32( uiA, uiB ); + } else { + return softfloat_addMagsF32( uiA, uiB ); + } +#else + magsFuncPtr = + signF32UI( uiA ^ uiB ) ? softfloat_subMagsF32 : softfloat_addMagsF32; + return (*magsFuncPtr)( uiA, uiB ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_div.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_div.c new file mode 100644 index 000000000..05ec701f7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_div.c @@ -0,0 +1,180 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_div( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signB; + int_fast16_t expB; + uint_fast32_t sigB; + bool signZ; + struct exp16_sig32 normExpSig; + int_fast16_t expZ; +#ifdef SOFTFLOAT_FAST_DIV64TO32 + uint_fast64_t sig64A; + uint_fast32_t sigZ; +#else + uint_fast32_t sigZ; + uint_fast64_t rem; +#endif + uint_fast32_t uiZ; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF32UI( uiB ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0xFF ) { + if ( sigA ) goto propagateNaN; + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + goto invalid; + } + goto infinity; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! sigB ) { + if ( ! (expA | sigA) ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinite ); + goto infinity; + } + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA - expB + 0x7E; + sigA |= 0x00800000; + sigB |= 0x00800000; +#ifdef SOFTFLOAT_FAST_DIV64TO32 + if ( sigA < sigB ) { + --expZ; + sig64A = (uint_fast64_t) sigA<<31; + } else { + sig64A = (uint_fast64_t) sigA<<30; + } + sigZ = sig64A / sigB; + if ( ! (sigZ & 0x3F) ) sigZ |= ((uint_fast64_t) sigB * sigZ != sig64A); +#else + if ( sigA < sigB ) { + --expZ; + sigA <<= 8; + } else { + sigA <<= 7; + } + sigB <<= 8; + sigZ = ((uint_fast64_t) sigA * softfloat_approxRecip32_1( sigB ))>>32; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sigZ += 2; + if ( (sigZ & 0x3F) < 2 ) { + sigZ &= ~3; +#ifdef SOFTFLOAT_FAST_INT64 + rem = ((uint_fast64_t) sigA<<31) - (uint_fast64_t) sigZ * sigB; +#else + rem = ((uint_fast64_t) sigA<<32) - (uint_fast64_t) (sigZ<<1) * sigB; +#endif + if ( rem & UINT64_C( 0x8000000000000000 ) ) { + sigZ -= 4; + } else { + if ( rem ) sigZ |= 1; + } + } +#endif + return softfloat_roundPackToF32( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infinity: + uiZ = packToF32UI( signZ, 0xFF, 0 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ = packToF32UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq.c new file mode 100644 index 000000000..801bbfd73 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_eq( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) { + if ( + softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + return (uiA == uiB) || ! (uint32_t) ((uiA | uiB)<<1); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq_signaling.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq_signaling.c new file mode 100644 index 000000000..4c610ffae --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_eq_signaling.c @@ -0,0 +1,61 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f32_eq_signaling( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + return (uiA == uiB) || ! (uint32_t) ((uiA | uiB)<<1); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_isSignalingNaN.c new file mode 100644 index 000000000..f5954cbbc --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_isSignalingNaN.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_isSignalingNaN( float32_t a ) +{ + union ui32_f32 uA; + + uA.f = a; + return softfloat_isSigNaNF32UI( uA.ui ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le.c new file mode 100644 index 000000000..d89d1e88d --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f32_le( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1) + : (uiA == uiB) || (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le_quiet.c new file mode 100644 index 000000000..c2d4297a2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_le_quiet.c @@ -0,0 +1,71 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_le_quiet( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) { + if ( + softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1) + : (uiA == uiB) || (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt.c new file mode 100644 index 000000000..5b5fd2282 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f32_lt( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0) + : (uiA != uiB) && (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt_quiet.c new file mode 100644 index 000000000..015388143 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_lt_quiet.c @@ -0,0 +1,71 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_lt_quiet( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) { + if ( + softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0) + : (uiA != uiB) && (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mul.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mul.c new file mode 100644 index 000000000..f5c856002 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mul.c @@ -0,0 +1,137 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_mul( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signB; + int_fast16_t expB; + uint_fast32_t sigB; + bool signZ; + uint_fast32_t magBits; + struct exp16_sig32 normExpSig; + int_fast16_t expZ; + uint_fast32_t sigZ, uiZ; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF32UI( uiB ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0xFF ) { + if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN; + magBits = expB | sigB; + goto infArg; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + magBits = expA | sigA; + goto infArg; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zero; + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x7F; + sigA = (sigA | 0x00800000)<<7; + sigB = (sigB | 0x00800000)<<8; + sigZ = softfloat_shortShiftRightJam64( (uint_fast64_t) sigA * sigB, 32 ); + if ( sigZ < 0x40000000 ) { + --expZ; + sigZ <<= 1; + } + return softfloat_roundPackToF32( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infArg: + if ( ! magBits ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + } else { + uiZ = packToF32UI( signZ, 0xFF, 0 ); + } + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ = packToF32UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mulAdd.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mulAdd.c new file mode 100644 index 000000000..9a28e212c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_mulAdd.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + union ui32_f32 uC; + uint_fast32_t uiC; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + uC.f = c; + uiC = uC.ui; + return softfloat_mulAddF32( uiA, uiB, uiC, 0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_rem.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_rem.c new file mode 100644 index 000000000..b29bf416e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_rem.c @@ -0,0 +1,168 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_rem( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + union ui32_f32 uB; + uint_fast32_t uiB; + int_fast16_t expB; + uint_fast32_t sigB; + struct exp16_sig32 normExpSig; + uint32_t rem; + int_fast16_t expDiff; + uint32_t q, recip32, altRem, meanRem; + bool signRem; + uint_fast32_t uiZ; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0xFF ) { + if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN; + goto invalid; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + return a; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! sigB ) goto invalid; + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + rem = sigA | 0x00800000; + sigB |= 0x00800000; + expDiff = expA - expB; + if ( expDiff < 1 ) { + if ( expDiff < -1 ) return a; + sigB <<= 6; + if ( expDiff ) { + rem <<= 5; + q = 0; + } else { + rem <<= 6; + q = (sigB <= rem); + if ( q ) rem -= sigB; + } + } else { + recip32 = softfloat_approxRecip32_1( sigB<<8 ); + /*-------------------------------------------------------------------- + | Changing the shift of `rem' here requires also changing the initial + | subtraction from `expDiff'. + *--------------------------------------------------------------------*/ + rem <<= 7; + expDiff -= 31; + /*-------------------------------------------------------------------- + | The scale of `sigB' affects how many bits are obtained during each + | cycle of the loop. Currently this is 29 bits per loop iteration, + | which is believed to be the maximum possible. + *--------------------------------------------------------------------*/ + sigB <<= 6; + for (;;) { + q = (rem * (uint_fast64_t) recip32)>>32; + if ( expDiff < 0 ) break; + rem = -(q * (uint32_t) sigB); + expDiff -= 29; + } + /*-------------------------------------------------------------------- + | (`expDiff' cannot be less than -30 here.) + *--------------------------------------------------------------------*/ + q >>= ~expDiff & 31; + rem = (rem<<(expDiff + 30)) - q * (uint32_t) sigB; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + do { + altRem = rem; + ++q; + rem -= sigB; + } while ( ! (rem & 0x80000000) ); + meanRem = rem + altRem; + if ( (meanRem & 0x80000000) || (! meanRem && (q & 1)) ) rem = altRem; + signRem = signA; + if ( 0x80000000 <= rem ) { + signRem = ! signRem; + rem = -rem; + } + return softfloat_normRoundPackToF32( signRem, expB, rem ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + goto uiZ; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_roundToInt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_roundToInt.c new file mode 100644 index 000000000..305af79dd --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_roundToInt.c @@ -0,0 +1,120 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t uiZ, lastBitMask, roundBitsMask; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp <= 0x7E ) { + if ( !(uint32_t) (uiA<<1) ) return a; + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + uiZ = uiA & packToF32UI( 1, 0, 0 ); + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( !fracF32UI( uiA ) ) break; + case softfloat_round_near_maxMag: + if ( exp == 0x7E ) uiZ |= packToF32UI( 0, 0x7F, 0 ); + break; + case softfloat_round_min: + if ( uiZ ) uiZ = packToF32UI( 1, 0x7F, 0 ); + break; + case softfloat_round_max: + if ( !uiZ ) uiZ = packToF32UI( 0, 0x7F, 0 ); + break; +#ifdef SOFTFLOAT_ROUND_ODD + case softfloat_round_odd: + uiZ |= packToF32UI( 0, 0x7F, 0 ); + break; +#endif + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x96 <= exp ) { + if ( (exp == 0xFF) && fracF32UI( uiA ) ) { + uiZ = softfloat_propagateNaNF32UI( uiA, 0 ); + goto uiZ; + } + return a; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ = uiA; + lastBitMask = (uint_fast32_t) 1<<(0x96 - exp); + roundBitsMask = lastBitMask - 1; + if ( roundingMode == softfloat_round_near_maxMag ) { + uiZ += lastBitMask>>1; + } else if ( roundingMode == softfloat_round_near_even ) { + uiZ += lastBitMask>>1; + if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask; + } else if ( + roundingMode + == (signF32UI( uiZ ) ? softfloat_round_min : softfloat_round_max) + ) { + uiZ += roundBitsMask; + } + uiZ &= ~roundBitsMask; + if ( uiZ != uiA ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sqrt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sqrt.c new file mode 100644 index 000000000..9263bde59 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sqrt.c @@ -0,0 +1,121 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_sqrt( float32_t a ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA, uiZ; + struct exp16_sig32 normExpSig; + int_fast16_t expZ; + uint_fast32_t sigZ, shiftedSigZ; + uint32_t negRem; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0xFF ) { + if ( sigA ) { + uiZ = softfloat_propagateNaNF32UI( uiA, 0 ); + goto uiZ; + } + if ( ! signA ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signA ) { + if ( ! (expA | sigA) ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = ((expA - 0x7F)>>1) + 0x7E; + expA &= 1; + sigA = (sigA | 0x00800000)<<8; + sigZ = + ((uint_fast64_t) sigA * softfloat_approxRecipSqrt32_1( expA, sigA )) + >>32; + if ( expA ) sigZ >>= 1; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sigZ += 2; + if ( (sigZ & 0x3F) < 2 ) { + shiftedSigZ = sigZ>>2; + negRem = shiftedSigZ * shiftedSigZ; + sigZ &= ~3; + if ( negRem & 0x80000000 ) { + sigZ |= 1; + } else { + if ( negRem ) --sigZ; + } + } + return softfloat_roundPackToF32( 0, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sub.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sub.c new file mode 100644 index 000000000..383484dae --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_sub.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t f32_sub( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1) + float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t ); +#endif + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; +#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL) + if ( signF32UI( uiA ^ uiB ) ) { + return softfloat_addMagsF32( uiA, uiB ); + } else { + return softfloat_subMagsF32( uiA, uiB ); + } +#else + magsFuncPtr = + signF32UI( uiA ^ uiB ) ? softfloat_addMagsF32 : softfloat_subMagsF32; + return (*magsFuncPtr)( uiA, uiB ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80.c new file mode 100644 index 000000000..742ed649c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t f32_to_extF80( float32_t a ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t frac; + struct commonNaN commonNaN; + struct uint128 uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + struct exp16_sig32 normExpSig; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + frac = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0xFF ) { + if ( frac ) { + softfloat_f32UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToExtF80UI( &commonNaN ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + } else { + uiZ64 = packToExtF80UI64( sign, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ64 = packToExtF80UI64( sign, 0 ); + uiZ0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF32Sig( frac ); + exp = normExpSig.exp; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = packToExtF80UI64( sign, exp + 0x3F80 ); + uiZ0 = (uint_fast64_t) (frac | 0x00800000)<<40; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80M.c new file mode 100644 index 000000000..af7e32a76 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_extF80M.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f32_to_extF80M( float32_t a, extFloat80_t *zPtr ) +{ + + *zPtr = f32_to_extF80( a ); + +} + +#else + +void f32_to_extF80M( float32_t a, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + union ui32_f32 uA; + uint32_t uiA; + bool sign; + int_fast16_t exp; + uint32_t frac; + struct commonNaN commonNaN; + uint_fast16_t uiZ64; + uint32_t uiZ32; + struct exp16_sig32 normExpSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zSPtr = (struct extFloat80M *) zPtr; + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + frac = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0xFF ) { + if ( frac ) { + softfloat_f32UIToCommonNaN( uiA, &commonNaN ); + softfloat_commonNaNToExtF80M( &commonNaN, zSPtr ); + return; + } + uiZ64 = packToExtF80UI64( sign, 0x7FFF ); + uiZ32 = 0x80000000; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ64 = packToExtF80UI64( sign, 0 ); + uiZ32 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF32Sig( frac ); + exp = normExpSig.exp; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = packToExtF80UI64( sign, exp + 0x3F80 ); + uiZ32 = 0x80000000 | (uint32_t) frac<<8; + uiZ: + zSPtr->signExp = uiZ64; + zSPtr->signif = (uint64_t) uiZ32<<32; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128.c new file mode 100644 index 000000000..6a765a44e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t f32_to_f128( float32_t a ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t frac; + struct commonNaN commonNaN; + struct uint128 uiZ; + struct exp16_sig32 normExpSig; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + frac = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0xFF ) { + if ( frac ) { + softfloat_f32UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF128UI( &commonNaN ); + } else { + uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 ); + uiZ.v0 = 0; + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ.v64 = packToF128UI64( sign, 0, 0 ); + uiZ.v0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF32Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ.v64 = packToF128UI64( sign, exp + 0x3F80, (uint_fast64_t) frac<<25 ); + uiZ.v0 = 0; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128M.c new file mode 100644 index 000000000..ee7e6b367 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f128M.c @@ -0,0 +1,115 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f32_to_f128M( float32_t a, float128_t *zPtr ) +{ + + *zPtr = f32_to_f128( a ); + +} + +#else + +void f32_to_f128M( float32_t a, float128_t *zPtr ) +{ + uint32_t *zWPtr; + union ui32_f32 uA; + uint32_t uiA; + bool sign; + int_fast16_t exp; + uint32_t frac, uiZ64; + struct commonNaN commonNaN; + uint32_t uiZ96; + struct exp16_sig32 normExpSig; + uint64_t frac64; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + frac = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = 0; + if ( exp == 0xFF ) { + if ( frac ) { + softfloat_f32UIToCommonNaN( uiA, &commonNaN ); + softfloat_commonNaNToF128M( &commonNaN, zWPtr ); + return; + } + uiZ96 = packToF128UI96( sign, 0x7FFF, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ96 = packToF128UI96( sign, 0, 0 ); + goto uiZ; + } + normExpSig = softfloat_normSubnormalF32Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac64 = (uint64_t) frac<<25; + uiZ96 = packToF128UI96( sign, exp + 0x3F80, frac64>>32 ); + uiZ64 = frac64; + uiZ: + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = uiZ64; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f16.c new file mode 100644 index 000000000..a9e77b775 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f16.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t f32_to_f16( float32_t a ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t frac; + struct commonNaN commonNaN; + uint_fast16_t uiZ, frac16; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + frac = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0xFF ) { + if ( frac ) { + softfloat_f32UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF16UI( &commonNaN ); + } else { + uiZ = packToF16UI( sign, 0x1F, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac16 = frac>>9 | ((frac & 0x1FF) != 0); + if ( ! (exp | frac16) ) { + uiZ = packToF16UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f64.c new file mode 100644 index 000000000..4f97519e8 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_f64.c @@ -0,0 +1,93 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f32_to_f64( float32_t a ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t frac; + struct commonNaN commonNaN; + uint_fast64_t uiZ; + struct exp16_sig32 normExpSig; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + frac = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0xFF ) { + if ( frac ) { + softfloat_f32UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF64UI( &commonNaN ); + } else { + uiZ = packToF64UI( sign, 0x7FF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ = packToF64UI( sign, 0, 0 ); + goto uiZ; + } + normExpSig = softfloat_normSubnormalF32Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ = packToF64UI( sign, exp + 0x380, (uint_fast64_t) frac<<29 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32.c new file mode 100644 index 000000000..7d0356fbe --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32.c @@ -0,0 +1,84 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + uint_fast64_t sig64; + int_fast16_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow) + if ( (exp == 0xFF) && sig ) { +#if (i32_fromNaN == i32_fromPosOverflow) + sign = 0; +#elif (i32_fromNaN == i32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return i32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<32; + shiftDist = 0xAA - exp; + if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist ); + return softfloat_roundToI32( sign, sig64, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32_r_minMag.c new file mode 100644 index 000000000..7652f2ebb --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i32_r_minMag.c @@ -0,0 +1,89 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftDist; + bool sign; + int_fast32_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x9E - exp; + if ( 32 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF32UI( uiA ); + if ( shiftDist <= 0 ) { + if ( uiA == packToF32UI( 1, 0x9E, 0 ) ) return -0x7FFFFFFF - 1; + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0xFF) && sig ? i32_fromNaN + : sign ? i32_fromNegOverflow : i32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = (sig | 0x00800000)<<8; + absZ = sig>>shiftDist; + if ( exact && ((uint_fast32_t) absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftDist; +#ifdef SOFTFLOAT_FAST_INT64 + uint_fast64_t sig64, extra; + struct uint64_extra sig64Extra; +#else + uint32_t extSig[3]; +#endif + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0xBE - exp; + if ( shiftDist < 0 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0xFF) && sig ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= 0x00800000; +#ifdef SOFTFLOAT_FAST_INT64 + sig64 = (uint_fast64_t) sig<<40; + extra = 0; + if ( shiftDist ) { + sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist ); + sig64 = sig64Extra.v; + extra = sig64Extra.extra; + } + return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact ); +#else + extSig[indexWord( 3, 2 )] = sig<<8; + extSig[indexWord( 3, 1 )] = 0; + extSig[indexWord( 3, 0 )] = 0; + if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig ); + return softfloat_roundMToI64( sign, extSig, roundingMode, exact ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i64_r_minMag.c new file mode 100644 index 000000000..397ddf6d0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_i64_r_minMag.c @@ -0,0 +1,94 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftDist; + bool sign; + uint_fast64_t sig64; + int_fast64_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0xBE - exp; + if ( 64 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF32UI( uiA ); + if ( shiftDist <= 0 ) { + if ( uiA == packToF32UI( 1, 0xBE, 0 ) ) { + return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0xFF) && sig ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<40; + absZ = sig64>>shiftDist; + shiftDist = 40 - shiftDist; + if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return sign ? -absZ : absZ; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32.c new file mode 100644 index 000000000..cb47d9458 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32.c @@ -0,0 +1,84 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + uint_fast64_t sig64; + int_fast16_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow) + if ( (exp == 0xFF) && sig ) { +#if (ui32_fromNaN == ui32_fromPosOverflow) + sign = 0; +#elif (ui32_fromNaN == ui32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return ui32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<32; + shiftDist = 0xAA - exp; + if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist ); + return softfloat_roundToUI32( sign, sig64, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32_r_minMag.c new file mode 100644 index 000000000..cdeb75f9f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui32_r_minMag.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftDist; + bool sign; + uint_fast32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x9E - exp; + if ( 32 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF32UI( uiA ); + if ( sign || (shiftDist < 0) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0xFF) && sig ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = (sig | 0x00800000)<<8; + z = sig>>shiftDist; + if ( exact && (z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftDist; +#ifdef SOFTFLOAT_FAST_INT64 + uint_fast64_t sig64, extra; + struct uint64_extra sig64Extra; +#else + uint32_t extSig[3]; +#endif + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0xBE - exp; + if ( shiftDist < 0 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0xFF) && sig ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= 0x00800000; +#ifdef SOFTFLOAT_FAST_INT64 + sig64 = (uint_fast64_t) sig<<40; + extra = 0; + if ( shiftDist ) { + sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist ); + sig64 = sig64Extra.v; + extra = sig64Extra.extra; + } + return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact ); +#else + extSig[indexWord( 3, 2 )] = sig<<8; + extSig[indexWord( 3, 1 )] = 0; + extSig[indexWord( 3, 0 )] = 0; + if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig ); + return softfloat_roundMToUI64( sign, extSig, roundingMode, exact ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui64_r_minMag.c new file mode 100644 index 000000000..c0fe54f6e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f32_to_ui64_r_minMag.c @@ -0,0 +1,90 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftDist; + bool sign; + uint_fast64_t sig64, z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0xBE - exp; + if ( 64 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF32UI( uiA ); + if ( sign || (shiftDist < 0) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0xFF) && sig ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<40; + z = sig64>>shiftDist; + shiftDist = 40 - shiftDist; + if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_add.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_add.c new file mode 100644 index 000000000..42f840dc5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_add.c @@ -0,0 +1,74 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t f64_add( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool ); +#endif + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + return softfloat_addMagsF64( uiA, uiB, signA ); + } else { + return softfloat_subMagsF64( uiA, uiB, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_addMagsF64 : softfloat_subMagsF64; + return (*magsFuncPtr)( uiA, uiB, signA ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_div.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_div.c new file mode 100644 index 000000000..9c967bb74 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_div.c @@ -0,0 +1,172 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_div( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; + int_fast16_t expB; + uint_fast64_t sigB; + bool signZ; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; + uint32_t recip32, sig32Z, doubleTerm; + uint_fast64_t rem; + uint32_t q; + uint_fast64_t sigZ; + uint_fast64_t uiZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FF ) { + if ( sigA ) goto propagateNaN; + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + goto invalid; + } + goto infinity; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + goto zero; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! sigB ) { + if ( ! (expA | sigA) ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinite ); + goto infinity; + } + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA - expB + 0x3FE; + sigA |= UINT64_C( 0x0010000000000000 ); + sigB |= UINT64_C( 0x0010000000000000 ); + if ( sigA < sigB ) { + --expZ; + sigA <<= 11; + } else { + sigA <<= 10; + } + sigB <<= 11; + recip32 = softfloat_approxRecip32_1( sigB>>32 ) - 2; + sig32Z = ((uint32_t) (sigA>>32) * (uint_fast64_t) recip32)>>32; + doubleTerm = sig32Z<<1; + rem = + ((sigA - (uint_fast64_t) doubleTerm * (uint32_t) (sigB>>32))<<28) + - (uint_fast64_t) doubleTerm * ((uint32_t) sigB>>4); + q = (((uint32_t) (rem>>32) * (uint_fast64_t) recip32)>>32) + 4; + sigZ = ((uint_fast64_t) sig32Z<<32) + ((uint_fast64_t) q<<4); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (sigZ & 0x1FF) < 4<<4 ) { + q &= ~7; + sigZ &= ~(uint_fast64_t) 0x7F; + doubleTerm = q<<1; + rem = + ((rem - (uint_fast64_t) doubleTerm * (uint32_t) (sigB>>32))<<28) + - (uint_fast64_t) doubleTerm * ((uint32_t) sigB>>4); + if ( rem & UINT64_C( 0x8000000000000000 ) ) { + sigZ -= 1<<7; + } else { + if ( rem ) sigZ |= 1; + } + } + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infinity: + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ = packToF64UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq.c new file mode 100644 index 000000000..360200379 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_eq( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) { + if ( + softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + return (uiA == uiB) || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq_signaling.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq_signaling.c new file mode 100644 index 000000000..5daa17937 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_eq_signaling.c @@ -0,0 +1,61 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f64_eq_signaling( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + return (uiA == uiB) || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF )); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_isSignalingNaN.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_isSignalingNaN.c new file mode 100644 index 000000000..e5d38321e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_isSignalingNaN.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_isSignalingNaN( float64_t a ) +{ + union ui64_f64 uA; + + uA.f = a; + return softfloat_isSigNaNF64UI( uA.ui ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le.c new file mode 100644 index 000000000..0b43d0467 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le.c @@ -0,0 +1,67 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f64_le( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + (signA != signB) + ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + : (uiA == uiB) || (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le_quiet.c new file mode 100644 index 000000000..832eee7a7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_le_quiet.c @@ -0,0 +1,72 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_le_quiet( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) { + if ( + softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + (signA != signB) + ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + : (uiA == uiB) || (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt.c new file mode 100644 index 000000000..49ee05be0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt.c @@ -0,0 +1,67 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f64_lt( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + (signA != signB) + ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + : (uiA != uiB) && (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt_quiet.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt_quiet.c new file mode 100644 index 000000000..d64088054 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_lt_quiet.c @@ -0,0 +1,72 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_lt_quiet( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) { + if ( + softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + (signA != signB) + ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + : (uiA != uiB) && (signA ^ (uiA < uiB)); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mul.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mul.c new file mode 100644 index 000000000..222e91dce --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mul.c @@ -0,0 +1,150 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_mul( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; + int_fast16_t expB; + uint_fast64_t sigB; + bool signZ; + uint_fast64_t magBits; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; +#ifdef SOFTFLOAT_FAST_INT64 + struct uint128 sig128Z; +#else + uint32_t sig128Z[4]; +#endif + uint_fast64_t sigZ, uiZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + signZ = signA ^ signB; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FF ) { + if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN; + magBits = expB | sigB; + goto infArg; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + magBits = expA | sigA; + goto infArg; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zero; + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x3FF; + sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10; + sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11; +#ifdef SOFTFLOAT_FAST_INT64 + sig128Z = softfloat_mul64To128( sigA, sigB ); + sigZ = sig128Z.v64 | (sig128Z.v0 != 0); +#else + softfloat_mul64To128M( sigA, sigB, sig128Z ); + sigZ = + (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 | sig128Z[indexWord( 4, 2 )]; + if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1; +#endif + if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { + --expZ; + sigZ <<= 1; + } + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infArg: + if ( ! magBits ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + } else { + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + } + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zero: + uiZ = packToF64UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mulAdd.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mulAdd.c new file mode 100644 index 000000000..fea3d968b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_mulAdd.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + union ui64_f64 uC; + uint_fast64_t uiC; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + uC.f = c; + uiC = uC.ui; + return softfloat_mulAddF64( uiA, uiB, uiC, 0 ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_rem.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_rem.c new file mode 100644 index 000000000..ffce679aa --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_rem.c @@ -0,0 +1,189 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_rem( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + union ui64_f64 uB; + uint_fast64_t uiB; + int_fast16_t expB; + uint_fast64_t sigB; + struct exp16_sig64 normExpSig; + uint64_t rem; + int_fast16_t expDiff; + uint32_t q, recip32; + uint_fast64_t q64; + uint64_t altRem, meanRem; + bool signRem; + uint_fast64_t uiZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FF ) { + if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN; + goto invalid; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + return a; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA < expB - 1 ) return a; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expB ) { + if ( ! sigB ) goto invalid; + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + rem = sigA | UINT64_C( 0x0010000000000000 ); + sigB |= UINT64_C( 0x0010000000000000 ); + expDiff = expA - expB; + if ( expDiff < 1 ) { + if ( expDiff < -1 ) return a; + sigB <<= 9; + if ( expDiff ) { + rem <<= 8; + q = 0; + } else { + rem <<= 9; + q = (sigB <= rem); + if ( q ) rem -= sigB; + } + } else { + recip32 = softfloat_approxRecip32_1( sigB>>21 ); + /*-------------------------------------------------------------------- + | Changing the shift of `rem' here requires also changing the initial + | subtraction from `expDiff'. + *--------------------------------------------------------------------*/ + rem <<= 9; + expDiff -= 30; + /*-------------------------------------------------------------------- + | The scale of `sigB' affects how many bits are obtained during each + | cycle of the loop. Currently this is 29 bits per loop iteration, + | the maximum possible. + *--------------------------------------------------------------------*/ + sigB <<= 9; + for (;;) { + q64 = (uint32_t) (rem>>32) * (uint_fast64_t) recip32; + if ( expDiff < 0 ) break; + q = (q64 + 0x80000000)>>32; +#ifdef SOFTFLOAT_FAST_INT64 + rem <<= 29; +#else + rem = (uint_fast64_t) (uint32_t) (rem>>3)<<32; +#endif + rem -= q * (uint64_t) sigB; + if ( rem & UINT64_C( 0x8000000000000000 ) ) rem += sigB; + expDiff -= 29; + } + /*-------------------------------------------------------------------- + | (`expDiff' cannot be less than -29 here.) + *--------------------------------------------------------------------*/ + q = (uint32_t) (q64>>32)>>(~expDiff & 31); + rem = (rem<<(expDiff + 30)) - q * (uint64_t) sigB; + if ( rem & UINT64_C( 0x8000000000000000 ) ) { + altRem = rem + sigB; + goto selectRem; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + do { + altRem = rem; + ++q; + rem -= sigB; + } while ( ! (rem & UINT64_C( 0x8000000000000000 )) ); + selectRem: + meanRem = rem + altRem; + if ( + (meanRem & UINT64_C( 0x8000000000000000 )) || (! meanRem && (q & 1)) + ) { + rem = altRem; + } + signRem = signA; + if ( rem & UINT64_C( 0x8000000000000000 ) ) { + signRem = ! signRem; + rem = -rem; + } + return softfloat_normRoundPackToF64( signRem, expB, rem ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto uiZ; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_roundToInt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_roundToInt.c new file mode 100644 index 000000000..54e7b0542 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_roundToInt.c @@ -0,0 +1,120 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t uiZ, lastBitMask, roundBitsMask; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp <= 0x3FE ) { + if ( !(uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) return a; + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + uiZ = uiA & packToF64UI( 1, 0, 0 ); + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( !fracF64UI( uiA ) ) break; + case softfloat_round_near_maxMag: + if ( exp == 0x3FE ) uiZ |= packToF64UI( 0, 0x3FF, 0 ); + break; + case softfloat_round_min: + if ( uiZ ) uiZ = packToF64UI( 1, 0x3FF, 0 ); + break; + case softfloat_round_max: + if ( !uiZ ) uiZ = packToF64UI( 0, 0x3FF, 0 ); + break; +#ifdef SOFTFLOAT_ROUND_ODD + case softfloat_round_odd: + uiZ |= packToF64UI( 0, 0x3FF, 0 ); + break; +#endif + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x433 <= exp ) { + if ( (exp == 0x7FF) && fracF64UI( uiA ) ) { + uiZ = softfloat_propagateNaNF64UI( uiA, 0 ); + goto uiZ; + } + return a; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ = uiA; + lastBitMask = (uint_fast64_t) 1<<(0x433 - exp); + roundBitsMask = lastBitMask - 1; + if ( roundingMode == softfloat_round_near_maxMag ) { + uiZ += lastBitMask>>1; + } else if ( roundingMode == softfloat_round_near_even ) { + uiZ += lastBitMask>>1; + if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask; + } else if ( + roundingMode + == (signF64UI( uiZ ) ? softfloat_round_min : softfloat_round_max) + ) { + uiZ += roundBitsMask; + } + uiZ &= ~roundBitsMask; + if ( uiZ != uiA ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sqrt.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sqrt.c new file mode 100644 index 000000000..f9f226b69 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sqrt.c @@ -0,0 +1,133 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_sqrt( float64_t a ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA, uiZ; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; + uint32_t sig32A, recipSqrt32, sig32Z; + uint_fast64_t rem; + uint32_t q; + uint_fast64_t sigZ, shiftedSigZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FF ) { + if ( sigA ) { + uiZ = softfloat_propagateNaNF64UI( uiA, 0 ); + goto uiZ; + } + if ( ! signA ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signA ) { + if ( ! (expA | sigA) ) return a; + goto invalid; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + /*------------------------------------------------------------------------ + | (`sig32Z' is guaranteed to be a lower bound on the square root of + | `sig32A', which makes `sig32Z' also a lower bound on the square root of + | `sigA'.) + *------------------------------------------------------------------------*/ + expZ = ((expA - 0x3FF)>>1) + 0x3FE; + expA &= 1; + sigA |= UINT64_C( 0x0010000000000000 ); + sig32A = sigA>>21; + recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A ); + sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32; + if ( expA ) { + sigA <<= 8; + sig32Z >>= 1; + } else { + sigA <<= 9; + } + rem = sigA - (uint_fast64_t) sig32Z * sig32Z; + q = ((uint32_t) (rem>>2) * (uint_fast64_t) recipSqrt32)>>32; + sigZ = ((uint_fast64_t) sig32Z<<32 | 1<<5) + ((uint_fast64_t) q<<3); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (sigZ & 0x1FF) < 0x22 ) { + sigZ &= ~(uint_fast64_t) 0x3F; + shiftedSigZ = sigZ>>6; + rem = (sigA<<52) - shiftedSigZ * shiftedSigZ; + if ( rem & UINT64_C( 0x8000000000000000 ) ) { + --sigZ; + } else { + if ( rem ) sigZ |= 1; + } + } + return softfloat_roundPackToF64( 0, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sub.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sub.c new file mode 100644 index 000000000..b5ccb882b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_sub.c @@ -0,0 +1,74 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t f64_sub( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; +#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2) + float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool ); +#endif + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) + if ( signA == signB ) { + return softfloat_subMagsF64( uiA, uiB, signA ); + } else { + return softfloat_addMagsF64( uiA, uiB, signA ); + } +#else + magsFuncPtr = + (signA == signB) ? softfloat_subMagsF64 : softfloat_addMagsF64; + return (*magsFuncPtr)( uiA, uiB, signA ); +#endif + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80.c new file mode 100644 index 000000000..2799d9b07 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t f64_to_extF80( float64_t a ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t frac; + struct commonNaN commonNaN; + struct uint128 uiZ; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + struct exp16_sig64 normExpSig; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + frac = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FF ) { + if ( frac ) { + softfloat_f64UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToExtF80UI( &commonNaN ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + } else { + uiZ64 = packToExtF80UI64( sign, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ64 = packToExtF80UI64( sign, 0 ); + uiZ0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF64Sig( frac ); + exp = normExpSig.exp; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = packToExtF80UI64( sign, exp + 0x3C00 ); + uiZ0 = (frac | UINT64_C( 0x0010000000000000 ))<<11; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80M.c new file mode 100644 index 000000000..a2e67e46f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_extF80M.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f64_to_extF80M( float64_t a, extFloat80_t *zPtr ) +{ + + *zPtr = f64_to_extF80( a ); + +} + +#else + +void f64_to_extF80M( float64_t a, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + union ui64_f64 uA; + uint64_t uiA; + bool sign; + int_fast16_t exp; + uint64_t frac; + struct commonNaN commonNaN; + uint_fast16_t uiZ64; + uint64_t uiZ0; + struct exp16_sig64 normExpSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zSPtr = (struct extFloat80M *) zPtr; + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + frac = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FF ) { + if ( frac ) { + softfloat_f64UIToCommonNaN( uiA, &commonNaN ); + softfloat_commonNaNToExtF80M( &commonNaN, zSPtr ); + return; + } + uiZ64 = packToExtF80UI64( sign, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ64 = packToExtF80UI64( sign, 0 ); + uiZ0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF64Sig( frac ); + exp = normExpSig.exp; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ64 = packToExtF80UI64( sign, exp + 0x3C00 ); + uiZ0 = UINT64_C( 0x8000000000000000 ) | frac<<11; + uiZ: + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128.c new file mode 100644 index 000000000..60af3b0be --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t f64_to_f128( float64_t a ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t frac; + struct commonNaN commonNaN; + struct uint128 uiZ; + struct exp16_sig64 normExpSig; + struct uint128 frac128; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + frac = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FF ) { + if ( frac ) { + softfloat_f64UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF128UI( &commonNaN ); + } else { + uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 ); + uiZ.v0 = 0; + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ.v64 = packToF128UI64( sign, 0, 0 ); + uiZ.v0 = 0; + goto uiZ; + } + normExpSig = softfloat_normSubnormalF64Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac128 = softfloat_shortShiftLeft128( 0, frac, 60 ); + uiZ.v64 = packToF128UI64( sign, exp + 0x3C00, frac128.v64 ); + uiZ.v0 = frac128.v0; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128M.c new file mode 100644 index 000000000..fbc451537 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f128M.c @@ -0,0 +1,117 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void f64_to_f128M( float64_t a, float128_t *zPtr ) +{ + + *zPtr = f64_to_f128( a ); + +} + +#else + +void f64_to_f128M( float64_t a, float128_t *zPtr ) +{ + uint32_t *zWPtr; + union ui64_f64 uA; + uint64_t uiA; + bool sign; + int_fast16_t exp; + uint64_t frac; + struct commonNaN commonNaN; + uint32_t uiZ96; + struct exp16_sig64 normExpSig; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zWPtr = (uint32_t *) zPtr; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + frac = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zWPtr[indexWord( 4, 0 )] = 0; + if ( exp == 0x7FF ) { + if ( frac ) { + softfloat_f64UIToCommonNaN( uiA, &commonNaN ); + softfloat_commonNaNToF128M( &commonNaN, zWPtr ); + return; + } + uiZ96 = packToF128UI96( sign, 0x7FFF, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! exp ) { + if ( ! frac ) { + uiZ96 = packToF128UI96( sign, 0, 0 ); + goto uiZ; + } + normExpSig = softfloat_normSubnormalF64Sig( frac ); + exp = normExpSig.exp - 1; + frac = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zWPtr[indexWord( 4, 1 )] = (uint32_t) frac<<28; + frac >>= 4; + zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp + 0x3C00, frac>>32 ); + zWPtr[indexWord( 4, 2 )] = frac; + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiZ: + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f16.c new file mode 100644 index 000000000..121e3062a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f16.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t f64_to_f16( float64_t a ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t frac; + struct commonNaN commonNaN; + uint_fast16_t uiZ, frac16; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + frac = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FF ) { + if ( frac ) { + softfloat_f64UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF16UI( &commonNaN ); + } else { + uiZ = packToF16UI( sign, 0x1F, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac16 = softfloat_shortShiftRightJam64( frac, 38 ); + if ( ! (exp | frac16) ) { + uiZ = packToF16UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f32.c new file mode 100644 index 000000000..a18106556 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_f32.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f64_to_f32( float64_t a ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t frac; + struct commonNaN commonNaN; + uint_fast32_t uiZ, frac32; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + frac = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp == 0x7FF ) { + if ( frac ) { + softfloat_f64UIToCommonNaN( uiA, &commonNaN ); + uiZ = softfloat_commonNaNToF32UI( &commonNaN ); + } else { + uiZ = packToF32UI( sign, 0xFF, 0 ); + } + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + frac32 = softfloat_shortShiftRightJam64( frac, 22 ); + if ( ! (exp | frac32) ) { + uiZ = packToF32UI( sign, 0, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32.c new file mode 100644 index 000000000..8d9785b0b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32.c @@ -0,0 +1,82 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow) + if ( (exp == 0x7FF) && sig ) { +#if (i32_fromNaN == i32_fromPosOverflow) + sign = 0; +#elif (i32_fromNaN == i32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return i32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftDist = 0x427 - exp; + if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist ); + return softfloat_roundToI32( sign, sig, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32_r_minMag.c new file mode 100644 index 000000000..8b7a91f1c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i32_r_minMag.c @@ -0,0 +1,96 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; + bool sign; + int_fast32_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x433 - exp; + if ( 53 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF64UI( uiA ); + if ( shiftDist < 22 ) { + if ( + sign && (exp == 0x41E) && (sig < UINT64_C( 0x0000000000200000 )) + ) { + if ( exact && sig ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return -0x7FFFFFFF - 1; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FF) && sig ? i32_fromNaN + : sign ? i32_fromNegOverflow : i32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig |= UINT64_C( 0x0010000000000000 ); + absZ = sig>>shiftDist; + if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; +#ifdef SOFTFLOAT_FAST_INT64 + struct uint64_extra sigExtra; +#else + uint32_t extSig[3]; +#endif + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftDist = 0x433 - exp; +#ifdef SOFTFLOAT_FAST_INT64 + if ( shiftDist <= 0 ) { + if ( shiftDist < -11 ) goto invalid; + sigExtra.v = sig<<-shiftDist; + sigExtra.extra = 0; + } else { + sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist ); + } + return + softfloat_roundToI64( + sign, sigExtra.v, sigExtra.extra, roundingMode, exact ); +#else + extSig[indexWord( 3, 0 )] = 0; + if ( shiftDist <= 0 ) { + if ( shiftDist < -11 ) goto invalid; + sig <<= -shiftDist; + extSig[indexWord( 3, 2 )] = sig>>32; + extSig[indexWord( 3, 1 )] = sig; + } else { + extSig[indexWord( 3, 2 )] = sig>>32; + extSig[indexWord( 3, 1 )] = sig; + softfloat_shiftRightJam96M( extSig, shiftDist, extSig ); + } + return softfloat_roundMToI64( sign, extSig, roundingMode, exact ); +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FF) && fracF64UI( uiA ) ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i64_r_minMag.c new file mode 100644 index 000000000..56c6a1010 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_i64_r_minMag.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; + int_fast64_t absZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x433 - exp; + if ( shiftDist <= 0 ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( shiftDist < -10 ) { + if ( uiA == packToF64UI( 1, 0x43E, 0 ) ) { + return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FF) && sig ? i64_fromNaN + : sign ? i64_fromNegOverflow : i64_fromPosOverflow; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig |= UINT64_C( 0x0010000000000000 ); + absZ = sig<<-shiftDist; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( 53 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig |= UINT64_C( 0x0010000000000000 ); + absZ = sig>>shiftDist; + if ( exact && (absZ< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow) + if ( (exp == 0x7FF) && sig ) { +#if (ui32_fromNaN == ui32_fromPosOverflow) + sign = 0; +#elif (ui32_fromNaN == ui32_fromNegOverflow) + sign = 1; +#else + softfloat_raiseFlags( softfloat_flag_invalid ); + return ui32_fromNaN; +#endif + } +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftDist = 0x427 - exp; + if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist ); + return softfloat_roundToUI32( sign, sig, roundingMode, exact ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui32_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui32_r_minMag.c new file mode 100644 index 000000000..6e3d14e8f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui32_r_minMag.c @@ -0,0 +1,88 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; + bool sign; + uint_fast32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x433 - exp; + if ( 53 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF64UI( uiA ); + if ( sign || (shiftDist < 21) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FF) && sig ? ui32_fromNaN + : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig |= UINT64_C( 0x0010000000000000 ); + z = sig>>shiftDist; + if ( exact && ((uint_fast64_t) z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; +#ifdef SOFTFLOAT_FAST_INT64 + struct uint64_extra sigExtra; +#else + uint32_t extSig[3]; +#endif + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftDist = 0x433 - exp; +#ifdef SOFTFLOAT_FAST_INT64 + if ( shiftDist <= 0 ) { + if ( shiftDist < -11 ) goto invalid; + sigExtra.v = sig<<-shiftDist; + sigExtra.extra = 0; + } else { + sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist ); + } + return + softfloat_roundToUI64( + sign, sigExtra.v, sigExtra.extra, roundingMode, exact ); +#else + extSig[indexWord( 3, 0 )] = 0; + if ( shiftDist <= 0 ) { + if ( shiftDist < -11 ) goto invalid; + sig <<= -shiftDist; + extSig[indexWord( 3, 2 )] = sig>>32; + extSig[indexWord( 3, 1 )] = sig; + } else { + extSig[indexWord( 3, 2 )] = sig>>32; + extSig[indexWord( 3, 1 )] = sig; + softfloat_shiftRightJam96M( extSig, shiftDist, extSig ); + } + return softfloat_roundMToUI64( sign, extSig, roundingMode, exact ); +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FF) && fracF64UI( uiA ) ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui64_r_minMag.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui64_r_minMag.c new file mode 100644 index 000000000..87eb0d05c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/f64_to_ui64_r_minMag.c @@ -0,0 +1,93 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftDist; + bool sign; + uint_fast64_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uA.f = a; + uiA = uA.ui; + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 0x433 - exp; + if ( 53 <= shiftDist ) { + if ( exact && (exp | sig) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sign = signF64UI( uiA ); + if ( sign ) goto invalid; + if ( shiftDist <= 0 ) { + if ( shiftDist < -11 ) goto invalid; + z = (sig | UINT64_C( 0x0010000000000000 ))<<-shiftDist; + } else { + sig |= UINT64_C( 0x0010000000000000 ); + z = sig>>shiftDist; + if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + } + return z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + (exp == 0x7FF) && sig ? ui64_fromNaN + : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80.c new file mode 100644 index 000000000..8036fa9f1 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +extFloat80_t i32_to_extF80( int32_t a ) +{ + uint_fast16_t uiZ64; + uint_fast32_t absA; + bool sign; + int_fast8_t shiftDist; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + uiZ64 = 0; + absA = 0; + if ( a ) { + sign = (a < 0); + absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; + shiftDist = softfloat_countLeadingZeros32( absA ); + uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist ); + absA <<= shiftDist; + } + uZ.s.signExp = uiZ64; + uZ.s.signif = (uint_fast64_t) absA<<32; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80M.c new file mode 100644 index 000000000..6d5431c1c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_extF80M.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void i32_to_extF80M( int32_t a, extFloat80_t *zPtr ) +{ + + *zPtr = i32_to_extF80( a ); + +} + +#else + +void i32_to_extF80M( int32_t a, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + uint_fast16_t uiZ64; + uint64_t sigZ; + bool sign; + uint32_t absA; + int_fast8_t shiftDist; + + zSPtr = (struct extFloat80M *) zPtr; + uiZ64 = 0; + sigZ = 0; + if ( a ) { + sign = (a < 0); + absA = sign ? -(uint32_t) a : (uint32_t) a; + shiftDist = softfloat_countLeadingZeros32( absA ); + uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist ); + sigZ = (uint64_t) (absA<signExp = uiZ64; + zSPtr->signif = sigZ; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f128.c new file mode 100644 index 000000000..a7d55cba4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f128.c @@ -0,0 +1,64 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t i32_to_f128( int32_t a ) +{ + uint_fast64_t uiZ64; + bool sign; + uint_fast32_t absA; + int_fast8_t shiftDist; + union ui128_f128 uZ; + + uiZ64 = 0; + if ( a ) { + sign = (a < 0); + absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; + shiftDist = softfloat_countLeadingZeros32( absA ) + 17; + uiZ64 = + packToF128UI64( + sign, 0x402E - shiftDist, (uint_fast64_t) absA< +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void i32_to_f128M( int32_t a, float128_t *zPtr ) +{ + + *zPtr = i32_to_f128( a ); + +} + +#else + +void i32_to_f128M( int32_t a, float128_t *zPtr ) +{ + uint32_t *zWPtr; + uint32_t uiZ96, uiZ64; + bool sign; + uint32_t absA; + int_fast8_t shiftDist; + uint64_t normAbsA; + + zWPtr = (uint32_t *) zPtr; + uiZ96 = 0; + uiZ64 = 0; + if ( a ) { + sign = (a < 0); + absA = sign ? -(uint32_t) a : (uint32_t) a; + shiftDist = softfloat_countLeadingZeros32( absA ) + 17; + normAbsA = (uint64_t) absA<>32 ); + uiZ64 = normAbsA; + } + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = uiZ64; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f16.c new file mode 100644 index 000000000..d3117248a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f16.c @@ -0,0 +1,71 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t i32_to_f16( int32_t a ) +{ + bool sign; + uint_fast32_t absA; + int_fast8_t shiftDist; + union ui16_f16 u; + uint_fast16_t sig; + + sign = (a < 0); + absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; + shiftDist = softfloat_countLeadingZeros32( absA ) - 21; + if ( 0 <= shiftDist ) { + u.ui = + a ? packToF16UI( + sign, 0x18 - shiftDist, (uint_fast16_t) absA<>(-shiftDist) + | ((uint32_t) (absA<<(shiftDist & 31)) != 0) + : (uint_fast16_t) absA< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t i32_to_f32( int32_t a ) +{ + bool sign; + union ui32_f32 uZ; + uint_fast32_t absA; + + sign = (a < 0); + if ( ! (a & 0x7FFFFFFF) ) { + uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0; + return uZ.f; + } + absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; + return softfloat_normRoundPackToF32( sign, 0x9C, absA ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f64.c new file mode 100644 index 000000000..24feda542 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i32_to_f64.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t i32_to_f64( int32_t a ) +{ + uint_fast64_t uiZ; + bool sign; + uint_fast32_t absA; + int_fast8_t shiftDist; + union ui64_f64 uZ; + + if ( ! a ) { + uiZ = 0; + } else { + sign = (a < 0); + absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a; + shiftDist = softfloat_countLeadingZeros32( absA ) + 21; + uiZ = + packToF64UI( + sign, 0x432 - shiftDist, (uint_fast64_t) absA< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +extFloat80_t i64_to_extF80( int64_t a ) +{ + uint_fast16_t uiZ64; + uint_fast64_t absA; + bool sign; + int_fast8_t shiftDist; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + uiZ64 = 0; + absA = 0; + if ( a ) { + sign = (a < 0); + absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a; + shiftDist = softfloat_countLeadingZeros64( absA ); + uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist ); + absA <<= shiftDist; + } + uZ.s.signExp = uiZ64; + uZ.s.signif = absA; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_extF80M.c new file mode 100644 index 000000000..4838dde6d --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_extF80M.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void i64_to_extF80M( int64_t a, extFloat80_t *zPtr ) +{ + + *zPtr = i64_to_extF80( a ); + +} + +#else + +void i64_to_extF80M( int64_t a, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + uint_fast16_t uiZ64; + uint64_t sigZ; + bool sign; + uint64_t absA; + int_fast8_t shiftDist; + + zSPtr = (struct extFloat80M *) zPtr; + uiZ64 = 0; + sigZ = 0; + if ( a ) { + sign = (a < 0); + absA = sign ? -(uint64_t) a : (uint64_t) a; + shiftDist = softfloat_countLeadingZeros64( absA ); + uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist ); + sigZ = absA<signExp = uiZ64; + zSPtr->signif = sigZ; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128.c new file mode 100644 index 000000000..fcb017939 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128.c @@ -0,0 +1,72 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t i64_to_f128( int64_t a ) +{ + uint_fast64_t uiZ64, uiZ0; + bool sign; + uint_fast64_t absA; + int_fast8_t shiftDist; + struct uint128 zSig; + union ui128_f128 uZ; + + if ( ! a ) { + uiZ64 = 0; + uiZ0 = 0; + } else { + sign = (a < 0); + absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a; + shiftDist = softfloat_countLeadingZeros64( absA ) + 49; + if ( 64 <= shiftDist ) { + zSig.v64 = absA<<(shiftDist - 64); + zSig.v0 = 0; + } else { + zSig = softfloat_shortShiftLeft128( 0, absA, shiftDist ); + } + uiZ64 = packToF128UI64( sign, 0x406E - shiftDist, zSig.v64 ); + uiZ0 = zSig.v0; + } + uZ.ui.v64 = uiZ64; + uZ.ui.v0 = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128M.c new file mode 100644 index 000000000..0a04eb8d0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f128M.c @@ -0,0 +1,92 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void i64_to_f128M( int64_t a, float128_t *zPtr ) +{ + + *zPtr = i64_to_f128( a ); + +} + +#else + +void i64_to_f128M( int64_t a, float128_t *zPtr ) +{ + uint32_t *zWPtr; + uint32_t uiZ96, uiZ64; + bool sign; + uint64_t absA; + uint_fast8_t shiftDist; + uint32_t *ptr; + + zWPtr = (uint32_t *) zPtr; + uiZ96 = 0; + uiZ64 = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + if ( a ) { + sign = (a < 0); + absA = sign ? -(uint64_t) a : (uint64_t) a; + shiftDist = softfloat_countLeadingZeros64( absA ) + 17; + if ( shiftDist < 32 ) { + ptr = zWPtr + indexMultiwordHi( 4, 3 ); + ptr[indexWord( 3, 2 )] = 0; + ptr[indexWord( 3, 1 )] = absA>>32; + ptr[indexWord( 3, 0 )] = absA; + softfloat_shortShiftLeft96M( ptr, shiftDist, ptr ); + ptr[indexWordHi( 3 )] = + packToF128UI96( + sign, 0x404E - shiftDist, ptr[indexWordHi( 3 )] ); + return; + } + absA <<= shiftDist - 32; + uiZ96 = packToF128UI96( sign, 0x404E - shiftDist, absA>>32 ); + uiZ64 = absA; + } + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = uiZ64; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f16.c new file mode 100644 index 000000000..cef7b6133 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/i64_to_f16.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t i64_to_f16( int64_t a ) +{ + bool sign; + uint_fast64_t absA; + int_fast8_t shiftDist; + union ui16_f16 u; + uint_fast16_t sig; + + sign = (a < 0); + absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a; + shiftDist = softfloat_countLeadingZeros64( absA ) - 53; + if ( 0 <= shiftDist ) { + u.ui = + a ? packToF16UI( + sign, 0x18 - shiftDist, (uint_fast16_t) absA< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t i64_to_f32( int64_t a ) +{ + bool sign; + uint_fast64_t absA; + int_fast8_t shiftDist; + union ui32_f32 u; + uint_fast32_t sig; + + sign = (a < 0); + absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a; + shiftDist = softfloat_countLeadingZeros64( absA ) - 40; + if ( 0 <= shiftDist ) { + u.ui = + a ? packToF32UI( + sign, 0x95 - shiftDist, (uint_fast32_t) absA< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t i64_to_f64( int64_t a ) +{ + bool sign; + union ui64_f64 uZ; + uint_fast64_t absA; + + sign = (a < 0); + if ( ! (a & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) { + uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0; + return uZ.f; + } + absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a; + return softfloat_normRoundPackToF64( sign, 0x43C, absA ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/internals.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/internals.h new file mode 100644 index 000000000..020b3402f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/internals.h @@ -0,0 +1,278 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef internals_h +#define internals_h 1 + +#include +#include +#include "primitives.h" +#include "softfloat_types.h" + +union ui16_f16 { uint16_t ui; float16_t f; }; +union ui32_f32 { uint32_t ui; float32_t f; }; +union ui64_f64 { uint64_t ui; float64_t f; }; + +#ifdef SOFTFLOAT_FAST_INT64 +union extF80M_extF80 { struct extFloat80M fM; extFloat80_t f; }; +union ui128_f128 { struct uint128 ui; float128_t f; }; +#endif + +enum { + softfloat_mulAdd_subC = 1, + softfloat_mulAdd_subProd = 2 +}; + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool ); + +#ifdef SOFTFLOAT_FAST_INT64 +uint_fast64_t + softfloat_roundToUI64( + bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool ); +#else +uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool ); +#endif + +int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool ); + +#ifdef SOFTFLOAT_FAST_INT64 +int_fast64_t + softfloat_roundToI64( + bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool ); +#else +int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool ); +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define signF16UI( a ) ((bool) ((uint16_t) (a)>>15)) +#define expF16UI( a ) ((int_fast8_t) ((a)>>10) & 0x1F) +#define fracF16UI( a ) ((a) & 0x03FF) +#define packToF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<10) + (sig)) + +#define isNaNF16UI( a ) (((~(a) & 0x7C00) == 0) && ((a) & 0x03FF)) + +struct exp8_sig16 { int_fast8_t exp; uint_fast16_t sig; }; +struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t ); + +float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t ); +float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t ); + +float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t ); +float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t ); +float16_t + softfloat_mulAddF16( + uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define signF32UI( a ) ((bool) ((uint32_t) (a)>>31)) +#define expF32UI( a ) ((int_fast16_t) ((a)>>23) & 0xFF) +#define fracF32UI( a ) ((a) & 0x007FFFFF) +#define packToF32UI( sign, exp, sig ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig)) + +#define isNaNF32UI( a ) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF)) + +struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; }; +struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t ); + +float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t ); +float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t ); + +float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t ); +float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t ); +float32_t + softfloat_mulAddF32( + uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define signF64UI( a ) ((bool) ((uint64_t) (a)>>63)) +#define expF64UI( a ) ((int_fast16_t) ((a)>>52) & 0x7FF) +#define fracF64UI( a ) ((a) & UINT64_C( 0x000FFFFFFFFFFFFF )) +#define packToF64UI( sign, exp, sig ) ((uint64_t) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<52) + (sig))) + +#define isNaNF64UI( a ) (((~(a) & UINT64_C( 0x7FF0000000000000 )) == 0) && ((a) & UINT64_C( 0x000FFFFFFFFFFFFF ))) + +struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; }; +struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t ); + +float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t ); +float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t ); + +float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool ); +float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool ); +float64_t + softfloat_mulAddF64( + uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define signExtF80UI64( a64 ) ((bool) ((uint16_t) (a64)>>15)) +#define expExtF80UI64( a64 ) ((a64) & 0x7FFF) +#define packToExtF80UI64( sign, exp ) ((uint_fast16_t) (sign)<<15 | (exp)) + +#define isNaNExtF80UI( a64, a0 ) ((((a64) & 0x7FFF) == 0x7FFF) && ((a0) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))) + +#ifdef SOFTFLOAT_FAST_INT64 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +struct exp32_sig64 { int_fast32_t exp; uint64_t sig; }; +struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t ); + +extFloat80_t + softfloat_roundPackToExtF80( + bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t ); +extFloat80_t + softfloat_normRoundPackToExtF80( + bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t ); + +extFloat80_t + softfloat_addMagsExtF80( + uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); +extFloat80_t + softfloat_subMagsExtF80( + uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define signF128UI64( a64 ) ((bool) ((uint64_t) (a64)>>63)) +#define expF128UI64( a64 ) ((int_fast32_t) ((a64)>>48) & 0x7FFF) +#define fracF128UI64( a64 ) ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF )) +#define packToF128UI64( sign, exp, sig64 ) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<48) + (sig64)) + +#define isNaNF128UI( a64, a0 ) (((~(a64) & UINT64_C( 0x7FFF000000000000 )) == 0) && (a0 || ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF )))) + +struct exp32_sig128 { int_fast32_t exp; struct uint128 sig; }; +struct exp32_sig128 + softfloat_normSubnormalF128Sig( uint_fast64_t, uint_fast64_t ); + +float128_t + softfloat_roundPackToF128( + bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t ); +float128_t + softfloat_normRoundPackToF128( + bool, int_fast32_t, uint_fast64_t, uint_fast64_t ); + +float128_t + softfloat_addMagsF128( + uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); +float128_t + softfloat_subMagsF128( + uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool ); +float128_t + softfloat_mulAddF128( + uint_fast64_t, + uint_fast64_t, + uint_fast64_t, + uint_fast64_t, + uint_fast64_t, + uint_fast64_t, + uint_fast8_t + ); + +#else + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +bool + softfloat_tryPropagateNaNExtF80M( + const struct extFloat80M *, + const struct extFloat80M *, + struct extFloat80M * + ); +void softfloat_invalidExtF80M( struct extFloat80M * ); + +int softfloat_normExtF80SigM( uint64_t * ); + +void + softfloat_roundPackMToExtF80M( + bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * ); +void + softfloat_normRoundPackMToExtF80M( + bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * ); + +void + softfloat_addExtF80M( + const struct extFloat80M *, + const struct extFloat80M *, + struct extFloat80M *, + bool + ); + +int + softfloat_compareNonnormExtF80M( + const struct extFloat80M *, const struct extFloat80M * ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define signF128UI96( a96 ) ((bool) ((uint32_t) (a96)>>31)) +#define expF128UI96( a96 ) ((int32_t) ((a96)>>16) & 0x7FFF) +#define fracF128UI96( a96 ) ((a96) & 0x0000FFFF) +#define packToF128UI96( sign, exp, sig96 ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<16) + (sig96)) + +bool softfloat_isNaNF128M( const uint32_t * ); + +bool + softfloat_tryPropagateNaNF128M( + const uint32_t *, const uint32_t *, uint32_t * ); +void softfloat_invalidF128M( uint32_t * ); + +int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * ); + +void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * ); +void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * ); + +void + softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool ); +void + softfloat_mulAddF128M( + const uint32_t *, + const uint32_t *, + const uint32_t *, + uint32_t *, + uint_fast8_t + ); + +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/opts-GCC.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/opts-GCC.h new file mode 100644 index 000000000..18c1523e9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/opts-GCC.h @@ -0,0 +1,114 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2017 The Regents of the University of California. All rights +reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef opts_GCC_h +#define opts_GCC_h 1 + +#ifdef INLINE + +#include +#include "primitiveTypes.h" + +#ifdef SOFTFLOAT_BUILTIN_CLZ + +INLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a ) + { return a ? __builtin_clz( a ) - 16 : 16; } +#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16 + +INLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a ) + { return a ? __builtin_clz( a ) : 32; } +#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32 + +INLINE uint_fast8_t softfloat_countLeadingZeros64( uint64_t a ) + { return a ? __builtin_clzll( a ) : 64; } +#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64 + +#endif + +#ifdef SOFTFLOAT_INTRINSIC_INT128 + +INLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b ) +{ + union { unsigned __int128 ui; struct uint128 s; } uZ; + uZ.ui = (unsigned __int128) a * ((uint_fast64_t) b<<32); + return uZ.s; +} +#define softfloat_mul64ByShifted32To128 softfloat_mul64ByShifted32To128 + +INLINE struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b ) +{ + union { unsigned __int128 ui; struct uint128 s; } uZ; + uZ.ui = (unsigned __int128) a * b; + return uZ.s; +} +#define softfloat_mul64To128 softfloat_mul64To128 + +INLINE +struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b ) +{ + union { unsigned __int128 ui; struct uint128 s; } uZ; + uZ.ui = ((unsigned __int128) a64<<64 | a0) * b; + return uZ.s; +} +#define softfloat_mul128By32 softfloat_mul128By32 + +INLINE +void + softfloat_mul128To256M( + uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr ) +{ + unsigned __int128 z0, mid1, mid, z128; + z0 = (unsigned __int128) a0 * b0; + mid1 = (unsigned __int128) a64 * b0; + mid = mid1 + (unsigned __int128) a0 * b64; + z128 = (unsigned __int128) a64 * b64; + z128 += (unsigned __int128) (mid < mid1)<<64 | mid>>64; + mid <<= 64; + z0 += mid; + z128 += (z0 < mid); + zPtr[indexWord( 4, 0 )] = z0; + zPtr[indexWord( 4, 1 )] = z0>>64; + zPtr[indexWord( 4, 2 )] = z128; + zPtr[indexWord( 4, 3 )] = z128>>64; +} +#define softfloat_mul128To256M softfloat_mul128To256M + +#endif + +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitiveTypes.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitiveTypes.h new file mode 100644 index 000000000..a4a6dd11c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitiveTypes.h @@ -0,0 +1,85 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef primitiveTypes_h +#define primitiveTypes_h 1 + +#include + +#ifdef SOFTFLOAT_FAST_INT64 + +#ifdef LITTLEENDIAN +struct uint128 { uint64_t v0, v64; }; +struct uint64_extra { uint64_t extra, v; }; +struct uint128_extra { uint64_t extra; struct uint128 v; }; +#else +struct uint128 { uint64_t v64, v0; }; +struct uint64_extra { uint64_t v, extra; }; +struct uint128_extra { struct uint128 v; uint64_t extra; }; +#endif + +#endif + +/*---------------------------------------------------------------------------- +| These macros are used to isolate the differences in word order between big- +| endian and little-endian platforms. +*----------------------------------------------------------------------------*/ +#ifdef LITTLEENDIAN +#define wordIncr 1 +#define indexWord( total, n ) (n) +#define indexWordHi( total ) ((total) - 1) +#define indexWordLo( total ) 0 +#define indexMultiword( total, m, n ) (n) +#define indexMultiwordHi( total, n ) ((total) - (n)) +#define indexMultiwordLo( total, n ) 0 +#define indexMultiwordHiBut( total, n ) (n) +#define indexMultiwordLoBut( total, n ) 0 +#define INIT_UINTM4( v3, v2, v1, v0 ) { v0, v1, v2, v3 } +#else +#define wordIncr -1 +#define indexWord( total, n ) ((total) - 1 - (n)) +#define indexWordHi( total ) 0 +#define indexWordLo( total ) ((total) - 1) +#define indexMultiword( total, m, n ) ((total) - 1 - (m)) +#define indexMultiwordHi( total, n ) 0 +#define indexMultiwordLo( total, n ) ((total) - (n)) +#define indexMultiwordHiBut( total, n ) 0 +#define indexMultiwordLoBut( total, n ) (n) +#define INIT_UINTM4( v3, v2, v1, v0 ) { v3, v2, v1, v0 } +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitives.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitives.h new file mode 100644 index 000000000..863ab45b5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/primitives.h @@ -0,0 +1,1160 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef primitives_h +#define primitives_h 1 + +#include +#include +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRightJam64 +/*---------------------------------------------------------------------------- +| Shifts 'a' right by the number of bits given in 'dist', which must be in +| the range 1 to 63. If any nonzero bits are shifted off, they are "jammed" +| into the least-significant bit of the shifted value by setting the least- +| significant bit to 1. This shifted-and-jammed value is returned. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist ) + { return a>>dist | ((a & (((uint_fast64_t) 1<>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0); +} +#else +uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist ); +#endif +#endif + +#ifndef softfloat_shiftRightJam64 +/*---------------------------------------------------------------------------- +| Shifts 'a' right by the number of bits given in 'dist', which must not +| be zero. If any nonzero bits are shifted off, they are "jammed" into the +| least-significant bit of the shifted value by setting the least-significant +| bit to 1. This shifted-and-jammed value is returned. +| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is +| greater than 64, the result will be either 0 or 1, depending on whether 'a' +| is zero or nonzero. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL) +INLINE uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist ) +{ + return + (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0); +} +#else +uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist ); +#endif +#endif + +/*---------------------------------------------------------------------------- +| A constant table that translates an 8-bit unsigned integer (the array index) +| into the number of leading 0 bits before the most-significant 1 of that +| integer. For integer zero (index 0), the corresponding table element is 8. +*----------------------------------------------------------------------------*/ +extern const uint_least8_t softfloat_countLeadingZeros8[256]; + +#ifndef softfloat_countLeadingZeros16 +/*---------------------------------------------------------------------------- +| Returns the number of leading 0 bits before the most-significant 1 bit of +| 'a'. If 'a' is zero, 16 is returned. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a ) +{ + uint_fast8_t count = 8; + if ( 0x100 <= a ) { + count = 0; + a >>= 8; + } + count += softfloat_countLeadingZeros8[a]; + return count; +} +#else +uint_fast8_t softfloat_countLeadingZeros16( uint16_t a ); +#endif +#endif + +#ifndef softfloat_countLeadingZeros32 +/*---------------------------------------------------------------------------- +| Returns the number of leading 0 bits before the most-significant 1 bit of +| 'a'. If 'a' is zero, 32 is returned. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL) +INLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a ) +{ + uint_fast8_t count = 0; + if ( a < 0x10000 ) { + count = 16; + a <<= 16; + } + if ( a < 0x1000000 ) { + count += 8; + a <<= 8; + } + count += softfloat_countLeadingZeros8[a>>24]; + return count; +} +#else +uint_fast8_t softfloat_countLeadingZeros32( uint32_t a ); +#endif +#endif + +#ifndef softfloat_countLeadingZeros64 +/*---------------------------------------------------------------------------- +| Returns the number of leading 0 bits before the most-significant 1 bit of +| 'a'. If 'a' is zero, 64 is returned. +*----------------------------------------------------------------------------*/ +uint_fast8_t softfloat_countLeadingZeros64( uint64_t a ); +#endif + +extern const uint16_t softfloat_approxRecip_1k0s[16]; +extern const uint16_t softfloat_approxRecip_1k1s[16]; + +#ifndef softfloat_approxRecip32_1 +/*---------------------------------------------------------------------------- +| Returns an approximation to the reciprocal of the number represented by 'a', +| where 'a' is interpreted as an unsigned fixed-point number with one integer +| bit and 31 fraction bits. The 'a' input must be "normalized", meaning that +| its most-significant bit (bit 31) must be 1. Thus, if A is the value of +| the fixed-point interpretation of 'a', then 1 <= A < 2. The returned value +| is interpreted as a pure unsigned fraction, having no integer bits and 32 +| fraction bits. The approximation returned is never greater than the true +| reciprocal 1/A, and it differs from the true reciprocal by at most 2.006 ulp +| (units in the last place). +*----------------------------------------------------------------------------*/ +#ifdef SOFTFLOAT_FAST_DIV64TO32 +#define softfloat_approxRecip32_1( a ) ((uint32_t) (UINT64_C( 0x7FFFFFFFFFFFFFFF ) / (uint32_t) (a))) +#else +uint32_t softfloat_approxRecip32_1( uint32_t a ); +#endif +#endif + +extern const uint16_t softfloat_approxRecipSqrt_1k0s[16]; +extern const uint16_t softfloat_approxRecipSqrt_1k1s[16]; + +#ifndef softfloat_approxRecipSqrt32_1 +/*---------------------------------------------------------------------------- +| Returns an approximation to the reciprocal of the square root of the number +| represented by 'a', where 'a' is interpreted as an unsigned fixed-point +| number either with one integer bit and 31 fraction bits or with two integer +| bits and 30 fraction bits. The format of 'a' is determined by 'oddExpA', +| which must be either 0 or 1. If 'oddExpA' is 1, 'a' is interpreted as +| having one integer bit, and if 'oddExpA' is 0, 'a' is interpreted as having +| two integer bits. The 'a' input must be "normalized", meaning that its +| most-significant bit (bit 31) must be 1. Thus, if A is the value of the +| fixed-point interpretation of 'a', it follows that 1 <= A < 2 when 'oddExpA' +| is 1, and 2 <= A < 4 when 'oddExpA' is 0. +| The returned value is interpreted as a pure unsigned fraction, having +| no integer bits and 32 fraction bits. The approximation returned is never +| greater than the true reciprocal 1/sqrt(A), and it differs from the true +| reciprocal by at most 2.06 ulp (units in the last place). The approximation +| returned is also always within the range 0.5 to 1; thus, the most- +| significant bit of the result is always set. +*----------------------------------------------------------------------------*/ +uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a ); +#endif + +#ifdef SOFTFLOAT_FAST_INT64 + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is +| defined. +*----------------------------------------------------------------------------*/ + +#ifndef softfloat_eq128 +/*---------------------------------------------------------------------------- +| Returns true if the 128-bit unsigned integer formed by concatenating 'a64' +| and 'a0' is equal to the 128-bit unsigned integer formed by concatenating +| 'b64' and 'b0'. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL) +INLINE +bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) + { return (a64 == b64) && (a0 == b0); } +#else +bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ); +#endif +#endif + +#ifndef softfloat_le128 +/*---------------------------------------------------------------------------- +| Returns true if the 128-bit unsigned integer formed by concatenating 'a64' +| and 'a0' is less than or equal to the 128-bit unsigned integer formed by +| concatenating 'b64' and 'b0'. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) + { return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); } +#else +bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ); +#endif +#endif + +#ifndef softfloat_lt128 +/*---------------------------------------------------------------------------- +| Returns true if the 128-bit unsigned integer formed by concatenating 'a64' +| and 'a0' is less than the 128-bit unsigned integer formed by concatenating +| 'b64' and 'b0'. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) + { return (a64 < b64) || ((a64 == b64) && (a0 < b0)); } +#else +bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ); +#endif +#endif + +#ifndef softfloat_shortShiftLeft128 +/*---------------------------------------------------------------------------- +| Shifts the 128 bits formed by concatenating 'a64' and 'a0' left by the +| number of bits given in 'dist', which must be in the range 1 to 63. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +struct uint128 + softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist ) +{ + struct uint128 z; + z.v64 = a64<>(-dist & 63); + z.v0 = a0<>dist; + z.v0 = a64<<(-dist & 63) | a0>>dist; + return z; +} +#else +struct uint128 + softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist ); +#endif +#endif + +#ifndef softfloat_shortShiftRightJam64Extra +/*---------------------------------------------------------------------------- +| This function is the same as 'softfloat_shiftRightJam64Extra' (below), +| except that 'dist' must be in the range 1 to 63. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +struct uint64_extra + softfloat_shortShiftRightJam64Extra( + uint64_t a, uint64_t extra, uint_fast8_t dist ) +{ + struct uint64_extra z; + z.v = a>>dist; + z.extra = a<<(-dist & 63) | (extra != 0); + return z; +} +#else +struct uint64_extra + softfloat_shortShiftRightJam64Extra( + uint64_t a, uint64_t extra, uint_fast8_t dist ); +#endif +#endif + +#ifndef softfloat_shortShiftRightJam128 +/*---------------------------------------------------------------------------- +| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the +| number of bits given in 'dist', which must be in the range 1 to 63. If any +| nonzero bits are shifted off, they are "jammed" into the least-significant +| bit of the shifted value by setting the least-significant bit to 1. This +| shifted-and-jammed value is returned. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL) +INLINE +struct uint128 + softfloat_shortShiftRightJam128( + uint64_t a64, uint64_t a0, uint_fast8_t dist ) +{ + uint_fast8_t negDist = -dist; + struct uint128 z; + z.v64 = a64>>dist; + z.v0 = + a64<<(negDist & 63) | a0>>dist + | ((uint64_t) (a0<<(negDist & 63)) != 0); + return z; +} +#else +struct uint128 + softfloat_shortShiftRightJam128( + uint64_t a64, uint64_t a0, uint_fast8_t dist ); +#endif +#endif + +#ifndef softfloat_shortShiftRightJam128Extra +/*---------------------------------------------------------------------------- +| This function is the same as 'softfloat_shiftRightJam128Extra' (below), +| except that 'dist' must be in the range 1 to 63. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL) +INLINE +struct uint128_extra + softfloat_shortShiftRightJam128Extra( + uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist ) +{ + uint_fast8_t negDist = -dist; + struct uint128_extra z; + z.v.v64 = a64>>dist; + z.v.v0 = a64<<(negDist & 63) | a0>>dist; + z.extra = a0<<(negDist & 63) | (extra != 0); + return z; +} +#else +struct uint128_extra + softfloat_shortShiftRightJam128Extra( + uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist ); +#endif +#endif + +#ifndef softfloat_shiftRightJam64Extra +/*---------------------------------------------------------------------------- +| Shifts the 128 bits formed by concatenating 'a' and 'extra' right by 64 +| _plus_ the number of bits given in 'dist', which must not be zero. This +| shifted value is at most 64 nonzero bits and is returned in the 'v' field +| of the 'struct uint64_extra' result. The 64-bit 'extra' field of the result +| contains a value formed as follows from the bits that were shifted off: The +| _last_ bit shifted off is the most-significant bit of the 'extra' field, and +| the other 63 bits of the 'extra' field are all zero if and only if _all_but_ +| _the_last_ bits shifted off were all zero. +| (This function makes more sense if 'a' and 'extra' are considered to form +| an unsigned fixed-point number with binary point between 'a' and 'extra'. +| This fixed-point value is shifted right by the number of bits given in +| 'dist', and the integer part of this shifted value is returned in the 'v' +| field of the result. The fractional part of the shifted value is modified +| as described above and returned in the 'extra' field of the result.) +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL) +INLINE +struct uint64_extra + softfloat_shiftRightJam64Extra( + uint64_t a, uint64_t extra, uint_fast32_t dist ) +{ + struct uint64_extra z; + if ( dist < 64 ) { + z.v = a>>dist; + z.extra = a<<(-dist & 63); + } else { + z.v = 0; + z.extra = (dist == 64) ? a : (a != 0); + } + z.extra |= (extra != 0); + return z; +} +#else +struct uint64_extra + softfloat_shiftRightJam64Extra( + uint64_t a, uint64_t extra, uint_fast32_t dist ); +#endif +#endif + +#ifndef softfloat_shiftRightJam128 +/*---------------------------------------------------------------------------- +| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the +| number of bits given in 'dist', which must not be zero. If any nonzero bits +| are shifted off, they are "jammed" into the least-significant bit of the +| shifted value by setting the least-significant bit to 1. This shifted-and- +| jammed value is returned. +| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is +| greater than 128, the result will be either 0 or 1, depending on whether the +| original 128 bits are all zeros. +*----------------------------------------------------------------------------*/ +struct uint128 + softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist ); +#endif + +#ifndef softfloat_shiftRightJam128Extra +/*---------------------------------------------------------------------------- +| Shifts the 192 bits formed by concatenating 'a64', 'a0', and 'extra' right +| by 64 _plus_ the number of bits given in 'dist', which must not be zero. +| This shifted value is at most 128 nonzero bits and is returned in the 'v' +| field of the 'struct uint128_extra' result. The 64-bit 'extra' field of the +| result contains a value formed as follows from the bits that were shifted +| off: The _last_ bit shifted off is the most-significant bit of the 'extra' +| field, and the other 63 bits of the 'extra' field are all zero if and only +| if _all_but_the_last_ bits shifted off were all zero. +| (This function makes more sense if 'a64', 'a0', and 'extra' are considered +| to form an unsigned fixed-point number with binary point between 'a0' and +| 'extra'. This fixed-point value is shifted right by the number of bits +| given in 'dist', and the integer part of this shifted value is returned +| in the 'v' field of the result. The fractional part of the shifted value +| is modified as described above and returned in the 'extra' field of the +| result.) +*----------------------------------------------------------------------------*/ +struct uint128_extra + softfloat_shiftRightJam128Extra( + uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist ); +#endif + +#ifndef softfloat_shiftRightJam256M +/*---------------------------------------------------------------------------- +| Shifts the 256-bit unsigned integer pointed to by 'aPtr' right by the number +| of bits given in 'dist', which must not be zero. If any nonzero bits are +| shifted off, they are "jammed" into the least-significant bit of the shifted +| value by setting the least-significant bit to 1. This shifted-and-jammed +| value is stored at the location pointed to by 'zPtr'. Each of 'aPtr' and +| 'zPtr' points to an array of four 64-bit elements that concatenate in the +| platform's normal endian order to form a 256-bit integer. +| The value of 'dist' can be arbitrarily large. In particular, if 'dist' +| is greater than 256, the stored result will be either 0 or 1, depending on +| whether the original 256 bits are all zeros. +*----------------------------------------------------------------------------*/ +void + softfloat_shiftRightJam256M( + const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr ); +#endif + +#ifndef softfloat_add128 +/*---------------------------------------------------------------------------- +| Returns the sum of the 128-bit integer formed by concatenating 'a64' and +| 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'. The +| addition is modulo 2^128, so any carry out is lost. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +struct uint128 + softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + struct uint128 z; + z.v0 = a0 + b0; + z.v64 = a64 + b64 + (z.v0 < a0); + return z; +} +#else +struct uint128 + softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ); +#endif +#endif + +#ifndef softfloat_add256M +/*---------------------------------------------------------------------------- +| Adds the two 256-bit integers pointed to by 'aPtr' and 'bPtr'. The addition +| is modulo 2^256, so any carry out is lost. The sum is stored at the +| location pointed to by 'zPtr'. Each of 'aPtr', 'bPtr', and 'zPtr' points to +| an array of four 64-bit elements that concatenate in the platform's normal +| endian order to form a 256-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_add256M( + const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr ); +#endif + +#ifndef softfloat_sub128 +/*---------------------------------------------------------------------------- +| Returns the difference of the 128-bit integer formed by concatenating 'a64' +| and 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'. +| The subtraction is modulo 2^128, so any borrow out (carry out) is lost. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +struct uint128 + softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + struct uint128 z; + z.v0 = a0 - b0; + z.v64 = a64 - b64; + z.v64 -= (a0 < b0); + return z; +} +#else +struct uint128 + softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ); +#endif +#endif + +#ifndef softfloat_sub256M +/*---------------------------------------------------------------------------- +| Subtracts the 256-bit integer pointed to by 'bPtr' from the 256-bit integer +| pointed to by 'aPtr'. The addition is modulo 2^256, so any borrow out +| (carry out) is lost. The difference is stored at the location pointed to +| by 'zPtr'. Each of 'aPtr', 'bPtr', and 'zPtr' points to an array of four +| 64-bit elements that concatenate in the platform's normal endian order to +| form a 256-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_sub256M( + const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr ); +#endif + +#ifndef softfloat_mul64ByShifted32To128 +/*---------------------------------------------------------------------------- +| Returns the 128-bit product of 'a', 'b', and 2^32. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL) +INLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b ) +{ + uint_fast64_t mid; + struct uint128 z; + mid = (uint_fast64_t) (uint32_t) a * b; + z.v0 = mid<<32; + z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32); + return z; +} +#else +struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b ); +#endif +#endif + +#ifndef softfloat_mul64To128 +/*---------------------------------------------------------------------------- +| Returns the 128-bit product of 'a' and 'b'. +*----------------------------------------------------------------------------*/ +struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b ); +#endif + +#ifndef softfloat_mul128By32 +/*---------------------------------------------------------------------------- +| Returns the product of the 128-bit integer formed by concatenating 'a64' and +| 'a0', multiplied by 'b'. The multiplication is modulo 2^128; any overflow +| bits are discarded. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL) +INLINE +struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b ) +{ + struct uint128 z; + uint_fast64_t mid; + uint_fast32_t carry; + z.v0 = a0 * b; + mid = (uint_fast64_t) (uint32_t) (a0>>32) * b; + carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid); + z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32); + return z; +} +#else +struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b ); +#endif +#endif + +#ifndef softfloat_mul128To256M +/*---------------------------------------------------------------------------- +| Multiplies the 128-bit unsigned integer formed by concatenating 'a64' and +| 'a0' by the 128-bit unsigned integer formed by concatenating 'b64' and +| 'b0'. The 256-bit product is stored at the location pointed to by 'zPtr'. +| Argument 'zPtr' points to an array of four 64-bit elements that concatenate +| in the platform's normal endian order to form a 256-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_mul128To256M( + uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr ); +#endif + +#else + +/*---------------------------------------------------------------------------- +| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not +| defined. +*----------------------------------------------------------------------------*/ + +#ifndef softfloat_compare96M +/*---------------------------------------------------------------------------- +| Compares the two 96-bit unsigned integers pointed to by 'aPtr' and 'bPtr'. +| Returns -1 if the first integer (A) is less than the second (B); returns 0 +| if the two integers are equal; and returns +1 if the first integer (A) +| is greater than the second (B). (The result is thus the signum of A - B.) +| Each of 'aPtr' and 'bPtr' points to an array of three 32-bit elements that +| concatenate in the platform's normal endian order to form a 96-bit integer. +*----------------------------------------------------------------------------*/ +int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr ); +#endif + +#ifndef softfloat_compare128M +/*---------------------------------------------------------------------------- +| Compares the two 128-bit unsigned integers pointed to by 'aPtr' and 'bPtr'. +| Returns -1 if the first integer (A) is less than the second (B); returns 0 +| if the two integers are equal; and returns +1 if the first integer (A) +| is greater than the second (B). (The result is thus the signum of A - B.) +| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that +| concatenate in the platform's normal endian order to form a 128-bit integer. +*----------------------------------------------------------------------------*/ +int_fast8_t + softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr ); +#endif + +#ifndef softfloat_shortShiftLeft64To96M +/*---------------------------------------------------------------------------- +| Extends 'a' to 96 bits and shifts the value left by the number of bits given +| in 'dist', which must be in the range 1 to 31. The result is stored at the +| location pointed to by 'zPtr'. Argument 'zPtr' points to an array of three +| 32-bit elements that concatenate in the platform's normal endian order to +| form a 96-bit integer. +*----------------------------------------------------------------------------*/ +#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL) +INLINE +void + softfloat_shortShiftLeft64To96M( + uint64_t a, uint_fast8_t dist, uint32_t *zPtr ) +{ + zPtr[indexWord( 3, 0 )] = (uint32_t) a<>= 32 - dist; + zPtr[indexWord( 3, 2 )] = a>>32; + zPtr[indexWord( 3, 1 )] = a; +} +#else +void + softfloat_shortShiftLeft64To96M( + uint64_t a, uint_fast8_t dist, uint32_t *zPtr ); +#endif +#endif + +#ifndef softfloat_shortShiftLeftM +/*---------------------------------------------------------------------------- +| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number +| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist' +| must be in the range 1 to 31. Any nonzero bits shifted off are lost. The +| shifted N-bit result is stored at the location pointed to by 'zPtr'. Each +| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements +| that concatenate in the platform's normal endian order to form an N-bit +| integer. +*----------------------------------------------------------------------------*/ +void + softfloat_shortShiftLeftM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint_fast8_t dist, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_shortShiftLeft96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shortShiftLeftM' with +| 'size_words' = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_shortShiftLeft96M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 3, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shortShiftLeft128M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shortShiftLeftM' with +| 'size_words' = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_shortShiftLeft128M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 4, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shortShiftLeft160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shortShiftLeftM' with +| 'size_words' = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_shortShiftLeft160M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 5, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shiftLeftM +/*---------------------------------------------------------------------------- +| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number +| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist' +| must not be zero. Any nonzero bits shifted off are lost. The shifted +| N-bit result is stored at the location pointed to by 'zPtr'. Each of 'aPtr' +| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that +| concatenate in the platform's normal endian order to form an N-bit integer. +| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is +| greater than N, the stored result will be 0. +*----------------------------------------------------------------------------*/ +void + softfloat_shiftLeftM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint32_t dist, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_shiftLeft96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shiftLeftM' with +| 'size_words' = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_shiftLeft96M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 3, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shiftLeft128M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shiftLeftM' with +| 'size_words' = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_shiftLeft128M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 4, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shiftLeft160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shiftLeftM' with +| 'size_words' = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_shiftLeft160M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 5, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shortShiftRightM +/*---------------------------------------------------------------------------- +| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number +| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist' +| must be in the range 1 to 31. Any nonzero bits shifted off are lost. The +| shifted N-bit result is stored at the location pointed to by 'zPtr'. Each +| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements +| that concatenate in the platform's normal endian order to form an N-bit +| integer. +*----------------------------------------------------------------------------*/ +void + softfloat_shortShiftRightM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint_fast8_t dist, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_shortShiftRight128M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shortShiftRightM' with +| 'size_words' = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_shortShiftRight128M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 4, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shortShiftRight160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shortShiftRightM' with +| 'size_words' = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_shortShiftRight160M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 5, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shortShiftRightJamM +/*---------------------------------------------------------------------------- +| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number +| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist' +| must be in the range 1 to 31. If any nonzero bits are shifted off, they are +| "jammed" into the least-significant bit of the shifted value by setting the +| least-significant bit to 1. This shifted-and-jammed N-bit result is stored +| at the location pointed to by 'zPtr'. Each of 'aPtr' and 'zPtr' points +| to a 'size_words'-long array of 32-bit elements that concatenate in the +| platform's normal endian order to form an N-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_shortShiftRightJamM( + uint_fast8_t, const uint32_t *, uint_fast8_t, uint32_t * ); +#endif + +#ifndef softfloat_shortShiftRightJam160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shortShiftRightJamM' with +| 'size_words' = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_shortShiftRightJam160M( aPtr, dist, zPtr ) softfloat_shortShiftRightJamM( 5, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shiftRightM +/*---------------------------------------------------------------------------- +| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number +| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist' +| must not be zero. Any nonzero bits shifted off are lost. The shifted +| N-bit result is stored at the location pointed to by 'zPtr'. Each of 'aPtr' +| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that +| concatenate in the platform's normal endian order to form an N-bit integer. +| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is +| greater than N, the stored result will be 0. +*----------------------------------------------------------------------------*/ +void + softfloat_shiftRightM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint32_t dist, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_shiftRight96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shiftRightM' with +| 'size_words' = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_shiftRight96M( aPtr, dist, zPtr ) softfloat_shiftRightM( 3, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shiftRightJamM +/*---------------------------------------------------------------------------- +| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number +| of bits given in 'dist', where N = 'size_words' * 32. The value of 'dist' +| must not be zero. If any nonzero bits are shifted off, they are "jammed" +| into the least-significant bit of the shifted value by setting the least- +| significant bit to 1. This shifted-and-jammed N-bit result is stored +| at the location pointed to by 'zPtr'. Each of 'aPtr' and 'zPtr' points +| to a 'size_words'-long array of 32-bit elements that concatenate in the +| platform's normal endian order to form an N-bit integer. +| The value of 'dist' can be arbitrarily large. In particular, if 'dist' +| is greater than N, the stored result will be either 0 or 1, depending on +| whether the original N bits are all zeros. +*----------------------------------------------------------------------------*/ +void + softfloat_shiftRightJamM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint32_t dist, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_shiftRightJam96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shiftRightJamM' with +| 'size_words' = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_shiftRightJam96M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 3, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shiftRightJam128M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shiftRightJamM' with +| 'size_words' = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_shiftRightJam128M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 4, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_shiftRightJam160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_shiftRightJamM' with +| 'size_words' = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_shiftRightJam160M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 5, aPtr, dist, zPtr ) +#endif + +#ifndef softfloat_addM +/*---------------------------------------------------------------------------- +| Adds the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N = +| 'size_words' * 32. The addition is modulo 2^N, so any carry out is lost. +| The N-bit sum is stored at the location pointed to by 'zPtr'. Each of +| 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long array of 32-bit +| elements that concatenate in the platform's normal endian order to form an +| N-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_addM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_add96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_addM' with 'size_words' +| = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_add96M( aPtr, bPtr, zPtr ) softfloat_addM( 3, aPtr, bPtr, zPtr ) +#endif + +#ifndef softfloat_add128M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_addM' with 'size_words' +| = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_add128M( aPtr, bPtr, zPtr ) softfloat_addM( 4, aPtr, bPtr, zPtr ) +#endif + +#ifndef softfloat_add160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_addM' with 'size_words' +| = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_add160M( aPtr, bPtr, zPtr ) softfloat_addM( 5, aPtr, bPtr, zPtr ) +#endif + +#ifndef softfloat_addCarryM +/*---------------------------------------------------------------------------- +| Adds the two N-bit unsigned integers pointed to by 'aPtr' and 'bPtr', where +| N = 'size_words' * 32, plus 'carry', which must be either 0 or 1. The N-bit +| sum (modulo 2^N) is stored at the location pointed to by 'zPtr', and any +| carry out is returned as the result. Each of 'aPtr', 'bPtr', and 'zPtr' +| points to a 'size_words'-long array of 32-bit elements that concatenate in +| the platform's normal endian order to form an N-bit integer. +*----------------------------------------------------------------------------*/ +uint_fast8_t + softfloat_addCarryM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint_fast8_t carry, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_addComplCarryM +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_addCarryM', except that +| the value of the unsigned integer pointed to by 'bPtr' is bit-wise completed +| before the addition. +*----------------------------------------------------------------------------*/ +uint_fast8_t + softfloat_addComplCarryM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint_fast8_t carry, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_addComplCarry96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_addComplCarryM' with +| 'size_words' = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_addComplCarry96M( aPtr, bPtr, carry, zPtr ) softfloat_addComplCarryM( 3, aPtr, bPtr, carry, zPtr ) +#endif + +#ifndef softfloat_negXM +/*---------------------------------------------------------------------------- +| Replaces the N-bit unsigned integer pointed to by 'zPtr' by the +| 2s-complement of itself, where N = 'size_words' * 32. Argument 'zPtr' +| points to a 'size_words'-long array of 32-bit elements that concatenate in +| the platform's normal endian order to form an N-bit integer. +*----------------------------------------------------------------------------*/ +void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr ); +#endif + +#ifndef softfloat_negX96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_negXM' with 'size_words' +| = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_negX96M( zPtr ) softfloat_negXM( 3, zPtr ) +#endif + +#ifndef softfloat_negX128M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_negXM' with 'size_words' +| = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_negX128M( zPtr ) softfloat_negXM( 4, zPtr ) +#endif + +#ifndef softfloat_negX160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_negXM' with 'size_words' +| = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_negX160M( zPtr ) softfloat_negXM( 5, zPtr ) +#endif + +#ifndef softfloat_negX256M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_negXM' with 'size_words' +| = 8 (N = 256). +*----------------------------------------------------------------------------*/ +#define softfloat_negX256M( zPtr ) softfloat_negXM( 8, zPtr ) +#endif + +#ifndef softfloat_sub1XM +/*---------------------------------------------------------------------------- +| Subtracts 1 from the N-bit integer pointed to by 'zPtr', where N = +| 'size_words' * 32. The subtraction is modulo 2^N, so any borrow out (carry +| out) is lost. Argument 'zPtr' points to a 'size_words'-long array of 32-bit +| elements that concatenate in the platform's normal endian order to form an +| N-bit integer. +*----------------------------------------------------------------------------*/ +void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr ); +#endif + +#ifndef softfloat_sub1X96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_sub1XM' with 'size_words' +| = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_sub1X96M( zPtr ) softfloat_sub1XM( 3, zPtr ) +#endif + +#ifndef softfloat_sub1X160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_sub1XM' with 'size_words' +| = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_sub1X160M( zPtr ) softfloat_sub1XM( 5, zPtr ) +#endif + +#ifndef softfloat_subM +/*---------------------------------------------------------------------------- +| Subtracts the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N = +| 'size_words' * 32. The subtraction is modulo 2^N, so any borrow out (carry +| out) is lost. The N-bit difference is stored at the location pointed to by +| 'zPtr'. Each of 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long +| array of 32-bit elements that concatenate in the platform's normal endian +| order to form an N-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_subM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_sub96M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_subM' with 'size_words' +| = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_sub96M( aPtr, bPtr, zPtr ) softfloat_subM( 3, aPtr, bPtr, zPtr ) +#endif + +#ifndef softfloat_sub128M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_subM' with 'size_words' +| = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_sub128M( aPtr, bPtr, zPtr ) softfloat_subM( 4, aPtr, bPtr, zPtr ) +#endif + +#ifndef softfloat_sub160M +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_subM' with 'size_words' +| = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_sub160M( aPtr, bPtr, zPtr ) softfloat_subM( 5, aPtr, bPtr, zPtr ) +#endif + +#ifndef softfloat_mul64To128M +/*---------------------------------------------------------------------------- +| Multiplies 'a' and 'b' and stores the 128-bit product at the location +| pointed to by 'zPtr'. Argument 'zPtr' points to an array of four 32-bit +| elements that concatenate in the platform's normal endian order to form a +| 128-bit integer. +*----------------------------------------------------------------------------*/ +void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr ); +#endif + +#ifndef softfloat_mul128MTo256M +/*---------------------------------------------------------------------------- +| Multiplies the two 128-bit unsigned integers pointed to by 'aPtr' and +| 'bPtr', and stores the 256-bit product at the location pointed to by 'zPtr'. +| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that +| concatenate in the platform's normal endian order to form a 128-bit integer. +| Argument 'zPtr' points to an array of eight 32-bit elements that concatenate +| to form a 256-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_mul128MTo256M( + const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr ); +#endif + +#ifndef softfloat_remStepMBy32 +/*---------------------------------------------------------------------------- +| Performs a "remainder reduction step" as follows: Arguments 'remPtr' and +| 'bPtr' both point to N-bit unsigned integers, where N = 'size_words' * 32. +| Defining R and B as the values of those integers, the expression (R<<'dist') +| - B * q is computed modulo 2^N, and the N-bit result is stored at the +| location pointed to by 'zPtr'. Each of 'remPtr', 'bPtr', and 'zPtr' points +| to a 'size_words'-long array of 32-bit elements that concatenate in the +| platform's normal endian order to form an N-bit integer. +*----------------------------------------------------------------------------*/ +void + softfloat_remStepMBy32( + uint_fast8_t size_words, + const uint32_t *remPtr, + uint_fast8_t dist, + const uint32_t *bPtr, + uint32_t q, + uint32_t *zPtr + ); +#endif + +#ifndef softfloat_remStep96MBy32 +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_remStepMBy32' with +| 'size_words' = 3 (N = 96). +*----------------------------------------------------------------------------*/ +#define softfloat_remStep96MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 3, remPtr, dist, bPtr, q, zPtr ) +#endif + +#ifndef softfloat_remStep128MBy32 +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_remStepMBy32' with +| 'size_words' = 4 (N = 128). +*----------------------------------------------------------------------------*/ +#define softfloat_remStep128MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 4, remPtr, dist, bPtr, q, zPtr ) +#endif + +#ifndef softfloat_remStep160MBy32 +/*---------------------------------------------------------------------------- +| This function or macro is the same as 'softfloat_remStepMBy32' with +| 'size_words' = 5 (N = 160). +*----------------------------------------------------------------------------*/ +#define softfloat_remStep160MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 5, remPtr, dist, bPtr, q, zPtr ) +#endif + +#endif + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat.h new file mode 100644 index 000000000..b33374cd6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat.h @@ -0,0 +1,372 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + + +/*============================================================================ +| Note: If SoftFloat is made available as a general library for programs to +| use, it is strongly recommended that a platform-specific version of this +| header, "softfloat.h", be created that folds in "softfloat_types.h" and that +| eliminates all dependencies on compile-time macros. +*============================================================================*/ + + +#ifndef softfloat_h +#define softfloat_h 1 + +#include +#include +#include "softfloat_types.h" + +#ifndef THREAD_LOCAL +#define THREAD_LOCAL +#endif + +/*---------------------------------------------------------------------------- +| Software floating-point underflow tininess-detection mode. +*----------------------------------------------------------------------------*/ +extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess; +enum { + softfloat_tininess_beforeRounding = 0, + softfloat_tininess_afterRounding = 1 +}; + +/*---------------------------------------------------------------------------- +| Software floating-point rounding mode. (Mode "odd" is supported only if +| SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.) +*----------------------------------------------------------------------------*/ +extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode; +enum { + softfloat_round_near_even = 0, + softfloat_round_minMag = 1, + softfloat_round_min = 2, + softfloat_round_max = 3, + softfloat_round_near_maxMag = 4, + softfloat_round_odd = 6 +}; + +/*---------------------------------------------------------------------------- +| Software floating-point exception flags. +*----------------------------------------------------------------------------*/ +extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags; +enum { + softfloat_flag_inexact = 1, + softfloat_flag_underflow = 2, + softfloat_flag_overflow = 4, + softfloat_flag_infinite = 8, + softfloat_flag_invalid = 16 +}; + +/*---------------------------------------------------------------------------- +| Routine to raise any or all of the software floating-point exception flags. +*----------------------------------------------------------------------------*/ +void softfloat_raiseFlags( uint_fast8_t ); + +/*---------------------------------------------------------------------------- +| Integer-to-floating-point conversion routines. +*----------------------------------------------------------------------------*/ +float16_t ui32_to_f16( uint32_t ); +float32_t ui32_to_f32( uint32_t ); +float64_t ui32_to_f64( uint32_t ); +#ifdef SOFTFLOAT_FAST_INT64 +extFloat80_t ui32_to_extF80( uint32_t ); +float128_t ui32_to_f128( uint32_t ); +#endif +void ui32_to_extF80M( uint32_t, extFloat80_t * ); +void ui32_to_f128M( uint32_t, float128_t * ); +float16_t ui64_to_f16( uint64_t ); +float32_t ui64_to_f32( uint64_t ); +float64_t ui64_to_f64( uint64_t ); +#ifdef SOFTFLOAT_FAST_INT64 +extFloat80_t ui64_to_extF80( uint64_t ); +float128_t ui64_to_f128( uint64_t ); +#endif +void ui64_to_extF80M( uint64_t, extFloat80_t * ); +void ui64_to_f128M( uint64_t, float128_t * ); +float16_t i32_to_f16( int32_t ); +float32_t i32_to_f32( int32_t ); +float64_t i32_to_f64( int32_t ); +#ifdef SOFTFLOAT_FAST_INT64 +extFloat80_t i32_to_extF80( int32_t ); +float128_t i32_to_f128( int32_t ); +#endif +void i32_to_extF80M( int32_t, extFloat80_t * ); +void i32_to_f128M( int32_t, float128_t * ); +float16_t i64_to_f16( int64_t ); +float32_t i64_to_f32( int64_t ); +float64_t i64_to_f64( int64_t ); +#ifdef SOFTFLOAT_FAST_INT64 +extFloat80_t i64_to_extF80( int64_t ); +float128_t i64_to_f128( int64_t ); +#endif +void i64_to_extF80M( int64_t, extFloat80_t * ); +void i64_to_f128M( int64_t, float128_t * ); + +/*---------------------------------------------------------------------------- +| 16-bit (half-precision) floating-point operations. +*----------------------------------------------------------------------------*/ +uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool ); +uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool ); +int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool ); +int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool ); +uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool ); +uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool ); +int_fast32_t f16_to_i32_r_minMag( float16_t, bool ); +int_fast64_t f16_to_i64_r_minMag( float16_t, bool ); +float32_t f16_to_f32( float16_t ); +float64_t f16_to_f64( float16_t ); +#ifdef SOFTFLOAT_FAST_INT64 +extFloat80_t f16_to_extF80( float16_t ); +float128_t f16_to_f128( float16_t ); +#endif +void f16_to_extF80M( float16_t, extFloat80_t * ); +void f16_to_f128M( float16_t, float128_t * ); +float16_t f16_roundToInt( float16_t, uint_fast8_t, bool ); +float16_t f16_add( float16_t, float16_t ); +float16_t f16_sub( float16_t, float16_t ); +float16_t f16_mul( float16_t, float16_t ); +float16_t f16_mulAdd( float16_t, float16_t, float16_t ); +float16_t f16_div( float16_t, float16_t ); +float16_t f16_rem( float16_t, float16_t ); +float16_t f16_sqrt( float16_t ); +bool f16_eq( float16_t, float16_t ); +bool f16_le( float16_t, float16_t ); +bool f16_lt( float16_t, float16_t ); +bool f16_eq_signaling( float16_t, float16_t ); +bool f16_le_quiet( float16_t, float16_t ); +bool f16_lt_quiet( float16_t, float16_t ); +bool f16_isSignalingNaN( float16_t ); + +/*---------------------------------------------------------------------------- +| 32-bit (single-precision) floating-point operations. +*----------------------------------------------------------------------------*/ +uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool ); +uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool ); +int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool ); +int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool ); +uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool ); +uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool ); +int_fast32_t f32_to_i32_r_minMag( float32_t, bool ); +int_fast64_t f32_to_i64_r_minMag( float32_t, bool ); +float16_t f32_to_f16( float32_t ); +float64_t f32_to_f64( float32_t ); +#ifdef SOFTFLOAT_FAST_INT64 +extFloat80_t f32_to_extF80( float32_t ); +float128_t f32_to_f128( float32_t ); +#endif +void f32_to_extF80M( float32_t, extFloat80_t * ); +void f32_to_f128M( float32_t, float128_t * ); +float32_t f32_roundToInt( float32_t, uint_fast8_t, bool ); +float32_t f32_add( float32_t, float32_t ); +float32_t f32_sub( float32_t, float32_t ); +float32_t f32_mul( float32_t, float32_t ); +float32_t f32_mulAdd( float32_t, float32_t, float32_t ); +float32_t f32_div( float32_t, float32_t ); +float32_t f32_rem( float32_t, float32_t ); +float32_t f32_sqrt( float32_t ); +bool f32_eq( float32_t, float32_t ); +bool f32_le( float32_t, float32_t ); +bool f32_lt( float32_t, float32_t ); +bool f32_eq_signaling( float32_t, float32_t ); +bool f32_le_quiet( float32_t, float32_t ); +bool f32_lt_quiet( float32_t, float32_t ); +bool f32_isSignalingNaN( float32_t ); + +/*---------------------------------------------------------------------------- +| 64-bit (double-precision) floating-point operations. +*----------------------------------------------------------------------------*/ +uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool ); +uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool ); +int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool ); +int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool ); +uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool ); +uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool ); +int_fast32_t f64_to_i32_r_minMag( float64_t, bool ); +int_fast64_t f64_to_i64_r_minMag( float64_t, bool ); +float16_t f64_to_f16( float64_t ); +float32_t f64_to_f32( float64_t ); +#ifdef SOFTFLOAT_FAST_INT64 +extFloat80_t f64_to_extF80( float64_t ); +float128_t f64_to_f128( float64_t ); +#endif +void f64_to_extF80M( float64_t, extFloat80_t * ); +void f64_to_f128M( float64_t, float128_t * ); +float64_t f64_roundToInt( float64_t, uint_fast8_t, bool ); +float64_t f64_add( float64_t, float64_t ); +float64_t f64_sub( float64_t, float64_t ); +float64_t f64_mul( float64_t, float64_t ); +float64_t f64_mulAdd( float64_t, float64_t, float64_t ); +float64_t f64_div( float64_t, float64_t ); +float64_t f64_rem( float64_t, float64_t ); +float64_t f64_sqrt( float64_t ); +bool f64_eq( float64_t, float64_t ); +bool f64_le( float64_t, float64_t ); +bool f64_lt( float64_t, float64_t ); +bool f64_eq_signaling( float64_t, float64_t ); +bool f64_le_quiet( float64_t, float64_t ); +bool f64_lt_quiet( float64_t, float64_t ); +bool f64_isSignalingNaN( float64_t ); + +/*---------------------------------------------------------------------------- +| Rounding precision for 80-bit extended double-precision floating-point. +| Valid values are 32, 64, and 80. +*----------------------------------------------------------------------------*/ +extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision; + +/*---------------------------------------------------------------------------- +| 80-bit extended double-precision floating-point operations. +*----------------------------------------------------------------------------*/ +#ifdef SOFTFLOAT_FAST_INT64 +uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool ); +uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool ); +int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool ); +int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool ); +uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool ); +uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool ); +int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool ); +int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool ); +float16_t extF80_to_f16( extFloat80_t ); +float32_t extF80_to_f32( extFloat80_t ); +float64_t extF80_to_f64( extFloat80_t ); +float128_t extF80_to_f128( extFloat80_t ); +extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool ); +extFloat80_t extF80_add( extFloat80_t, extFloat80_t ); +extFloat80_t extF80_sub( extFloat80_t, extFloat80_t ); +extFloat80_t extF80_mul( extFloat80_t, extFloat80_t ); +extFloat80_t extF80_div( extFloat80_t, extFloat80_t ); +extFloat80_t extF80_rem( extFloat80_t, extFloat80_t ); +extFloat80_t extF80_sqrt( extFloat80_t ); +bool extF80_eq( extFloat80_t, extFloat80_t ); +bool extF80_le( extFloat80_t, extFloat80_t ); +bool extF80_lt( extFloat80_t, extFloat80_t ); +bool extF80_eq_signaling( extFloat80_t, extFloat80_t ); +bool extF80_le_quiet( extFloat80_t, extFloat80_t ); +bool extF80_lt_quiet( extFloat80_t, extFloat80_t ); +bool extF80_isSignalingNaN( extFloat80_t ); +#endif +uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool ); +uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool ); +int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool ); +int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool ); +uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool ); +uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool ); +int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool ); +int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool ); +float16_t extF80M_to_f16( const extFloat80_t * ); +float32_t extF80M_to_f32( const extFloat80_t * ); +float64_t extF80M_to_f64( const extFloat80_t * ); +void extF80M_to_f128M( const extFloat80_t *, float128_t * ); +void + extF80M_roundToInt( + const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ); +void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void extF80M_sqrt( const extFloat80_t *, extFloat80_t * ); +bool extF80M_eq( const extFloat80_t *, const extFloat80_t * ); +bool extF80M_le( const extFloat80_t *, const extFloat80_t * ); +bool extF80M_lt( const extFloat80_t *, const extFloat80_t * ); +bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * ); +bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * ); +bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * ); +bool extF80M_isSignalingNaN( const extFloat80_t * ); + +/*---------------------------------------------------------------------------- +| 128-bit (quadruple-precision) floating-point operations. +*----------------------------------------------------------------------------*/ +#ifdef SOFTFLOAT_FAST_INT64 +uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool ); +uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool ); +int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool ); +int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool ); +uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool ); +uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool ); +int_fast32_t f128_to_i32_r_minMag( float128_t, bool ); +int_fast64_t f128_to_i64_r_minMag( float128_t, bool ); +float16_t f128_to_f16( float128_t ); +float32_t f128_to_f32( float128_t ); +float64_t f128_to_f64( float128_t ); +extFloat80_t f128_to_extF80( float128_t ); +float128_t f128_roundToInt( float128_t, uint_fast8_t, bool ); +float128_t f128_add( float128_t, float128_t ); +float128_t f128_sub( float128_t, float128_t ); +float128_t f128_mul( float128_t, float128_t ); +float128_t f128_mulAdd( float128_t, float128_t, float128_t ); +float128_t f128_div( float128_t, float128_t ); +float128_t f128_rem( float128_t, float128_t ); +float128_t f128_sqrt( float128_t ); +bool f128_eq( float128_t, float128_t ); +bool f128_le( float128_t, float128_t ); +bool f128_lt( float128_t, float128_t ); +bool f128_eq_signaling( float128_t, float128_t ); +bool f128_le_quiet( float128_t, float128_t ); +bool f128_lt_quiet( float128_t, float128_t ); +bool f128_isSignalingNaN( float128_t ); +#endif +uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool ); +uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool ); +int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool ); +int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool ); +uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool ); +uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool ); +int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool ); +int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool ); +float16_t f128M_to_f16( const float128_t * ); +float32_t f128M_to_f32( const float128_t * ); +float64_t f128M_to_f64( const float128_t * ); +void f128M_to_extF80M( const float128_t *, extFloat80_t * ); +void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * ); +void f128M_add( const float128_t *, const float128_t *, float128_t * ); +void f128M_sub( const float128_t *, const float128_t *, float128_t * ); +void f128M_mul( const float128_t *, const float128_t *, float128_t * ); +void + f128M_mulAdd( + const float128_t *, const float128_t *, const float128_t *, float128_t * + ); +void f128M_div( const float128_t *, const float128_t *, float128_t * ); +void f128M_rem( const float128_t *, const float128_t *, float128_t * ); +void f128M_sqrt( const float128_t *, float128_t * ); +bool f128M_eq( const float128_t *, const float128_t * ); +bool f128M_le( const float128_t *, const float128_t * ); +bool f128M_lt( const float128_t *, const float128_t * ); +bool f128M_eq_signaling( const float128_t *, const float128_t * ); +bool f128M_le_quiet( const float128_t *, const float128_t * ); +bool f128M_lt_quiet( const float128_t *, const float128_t * ); +bool f128M_isSignalingNaN( const float128_t * ); + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat_types.h b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat_types.h new file mode 100644 index 000000000..bc30e3144 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/include/softfloat_types.h @@ -0,0 +1,81 @@ + +/*============================================================================ + +This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#ifndef softfloat_types_h +#define softfloat_types_h 1 + +#include + +/*---------------------------------------------------------------------------- +| Types used to pass 16-bit, 32-bit, 64-bit, and 128-bit floating-point +| arguments and results to/from functions. These types must be exactly +| 16 bits, 32 bits, 64 bits, and 128 bits in size, respectively. Where a +| platform has "native" support for IEEE-Standard floating-point formats, +| the types below may, if desired, be defined as aliases for the native types +| (typically 'float' and 'double', and possibly 'long double'). +*----------------------------------------------------------------------------*/ +typedef struct { uint16_t v; } float16_t; +typedef struct { uint32_t v; } float32_t; +typedef struct { uint64_t v; } float64_t; +typedef struct { uint64_t v[2]; } float128_t; + +/*---------------------------------------------------------------------------- +| The format of an 80-bit extended floating-point number in memory. This +| structure must contain a 16-bit field named 'signExp' and a 64-bit field +| named 'signif'. +*----------------------------------------------------------------------------*/ +#ifdef LITTLEENDIAN +struct extFloat80M { uint64_t signif; uint16_t signExp; }; +#else +struct extFloat80M { uint16_t signExp; uint64_t signif; }; +#endif + +/*---------------------------------------------------------------------------- +| The type used to pass 80-bit extended floating-point arguments and +| results to/from functions. This type must have size identical to +| 'struct extFloat80M'. Type 'extFloat80_t' can be defined as an alias for +| 'struct extFloat80M'. Alternatively, if a platform has "native" support +| for IEEE-Standard 80-bit extended floating-point, it may be possible, +| if desired, to define 'extFloat80_t' as an alias for the native type +| (presumably either 'long double' or a nonstandard compiler-intrinsic type). +| In that case, the 'signif' and 'signExp' fields of 'struct extFloat80M' +| must align exactly with the locations in memory of the sign, exponent, and +| significand of the native type. +*----------------------------------------------------------------------------*/ +typedef struct extFloat80M extFloat80_t; + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add128.c new file mode 100644 index 000000000..5a9d5082a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add128.c @@ -0,0 +1,55 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_add128 + +struct uint128 + softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + struct uint128 z; + + z.v0 = a0 + b0; + z.v64 = a64 + b64 + (z.v0 < a0); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add256M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add256M.c new file mode 100644 index 000000000..4fb46a174 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_add256M.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_add256M + +void + softfloat_add256M( + const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr ) +{ + unsigned int index; + uint_fast8_t carry; + uint64_t wordA, wordZ; + + index = indexWordLo( 4 ); + carry = 0; + for (;;) { + wordA = aPtr[index]; + wordZ = wordA + bPtr[index] + carry; + zPtr[index] = wordZ; + if ( index == indexWordHi( 4 ) ) break; + if ( wordZ != wordA ) carry = (wordZ < wordA); + index += wordIncr; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addCarryM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addCarryM.c new file mode 100644 index 000000000..f0ccf6724 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addCarryM.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_addCarryM + +uint_fast8_t + softfloat_addCarryM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint_fast8_t carry, + uint32_t *zPtr + ) +{ + unsigned int index, lastIndex; + uint32_t wordA, wordZ; + + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + for (;;) { + wordA = aPtr[index]; + wordZ = wordA + bPtr[index] + carry; + zPtr[index] = wordZ; + if ( wordZ != wordA ) carry = (wordZ < wordA); + if ( index == lastIndex ) break; + index += wordIncr; + } + return carry; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addComplCarryM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addComplCarryM.c new file mode 100644 index 000000000..e1584c669 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addComplCarryM.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_addComplCarryM + +uint_fast8_t + softfloat_addComplCarryM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint_fast8_t carry, + uint32_t *zPtr + ) +{ + unsigned int index, lastIndex; + uint32_t wordA, wordZ; + + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + for (;;) { + wordA = aPtr[index]; + wordZ = wordA + ~bPtr[index] + carry; + zPtr[index] = wordZ; + if ( wordZ != wordA ) carry = (wordZ < wordA); + if ( index == lastIndex ) break; + index += wordIncr; + } + return carry; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addExtF80M.c new file mode 100644 index 000000000..febfb6577 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addExtF80M.c @@ -0,0 +1,186 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +void + softfloat_addExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr, + bool negateB + ) +{ + uint32_t uiA64; + int32_t expA; + uint32_t uiB64; + int32_t expB; + uint32_t uiZ64; + bool signZ, signB; + const struct extFloat80M *tempSPtr; + uint64_t sigZ, sigB; + void + (*roundPackRoutinePtr)( + bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * ); + int32_t expDiff; + uint32_t extSigX[3], sigZExtra; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + expA = expExtF80UI64( uiA64 ); + uiB64 = bSPtr->signExp; + expB = expExtF80UI64( uiB64 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return; + uiZ64 = uiA64; + if ( expB == 0x7FFF ) { + uiZ64 = uiB64 ^ packToExtF80UI64( negateB, 0 ); + if ( (expA == 0x7FFF) && (uiZ64 != uiA64) ) { + softfloat_invalidExtF80M( zSPtr ); + return; + } + } + zSPtr->signExp = uiZ64; + zSPtr->signif = UINT64_C( 0x8000000000000000 ); + return; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signZ = signExtF80UI64( uiA64 ); + signB = signExtF80UI64( uiB64 ) ^ negateB; + negateB = (signZ != signB); + if ( expA < expB ) { + signZ = signB; + expA = expB; + expB = expExtF80UI64( uiA64 ); + tempSPtr = aSPtr; + aSPtr = bSPtr; + bSPtr = tempSPtr; + } + if ( ! expB ) { + expB = 1; + if ( ! expA ) expA = 1; + } + sigZ = aSPtr->signif; + sigB = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundPackRoutinePtr = softfloat_roundPackMToExtF80M; + expDiff = expA - expB; + if ( expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + extSigX[indexWord( 3, 2 )] = sigB>>32; + extSigX[indexWord( 3, 1 )] = sigB; + extSigX[indexWord( 3, 0 )] = 0; + softfloat_shiftRightJam96M( extSigX, expDiff, extSigX ); + sigB = + (uint64_t) extSigX[indexWord( 3, 2 )]<<32 + | extSigX[indexWord( 3, 1 )]; + if ( negateB ) { + sigZ -= sigB; + sigZExtra = extSigX[indexWordLo( 3 )]; + if ( sigZExtra ) { + --sigZ; + sigZExtra = -sigZExtra; + } + if ( ! (sigZ & UINT64_C( 0x8000000000000000 )) ) { + if ( sigZ & UINT64_C( 0x4000000000000000 ) ) { + --expA; + sigZ = sigZ<<1 | sigZExtra>>31; + sigZExtra <<= 1; + } else { + roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M; + } + } + } else { + sigZ += sigB; + if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto sigZ; + sigZExtra = (uint32_t) sigZ<<31 | (extSigX[indexWordLo( 3 )] != 0); + goto completeNormAfterAdd; + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sigZExtra = 0; + if ( negateB ) { + if ( sigZ < sigB ) { + signZ = ! signZ; + sigZ = sigB - sigZ; + } else { + sigZ -= sigB; + if ( ! sigZ ) { + signZ = (softfloat_roundingMode == softfloat_round_min); + zSPtr->signExp = packToExtF80UI64( signZ, 0 ); + zSPtr->signif = 0; + return; + } + } + roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M; + } else { + sigZ += sigB; + if ( sigZ < sigB ) { + sigZExtra = (uint32_t) sigZ<<31; + completeNormAfterAdd: + ++expA; + sigZ = UINT64_C( 0x8000000000000000 ) | sigZ>>1; + } else { + if ( ! (sigZ & UINT64_C( 0x8000000000000000 )) ) { + roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M; + } + } + } + } + extSigX[indexWord( 3, 0 )] = sigZExtra; + sigZ: + extSigX[indexWord( 3, 2 )] = sigZ>>32; + extSigX[indexWord( 3, 1 )] = sigZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundPack: + (*roundPackRoutinePtr)( + signZ, expA, extSigX, extF80_roundingPrecision, zSPtr ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addF128M.c new file mode 100644 index 000000000..8ed9d271f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addF128M.c @@ -0,0 +1,211 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +void + softfloat_addF128M( + const uint32_t *aWPtr, + const uint32_t *bWPtr, + uint32_t *zWPtr, + bool negateB + ) +{ + uint32_t uiA96; + int32_t expA; + uint32_t uiB96; + int32_t expB; + uint32_t uiZ96; + bool signZ, signB; + const uint32_t *tempPtr; + uint32_t sig96A, sig96B; + int32_t expDiff; + uint_fast8_t + (*addCarryMRoutinePtr)( + uint_fast8_t, + const uint32_t *, + const uint32_t *, + uint_fast8_t, + uint32_t * + ); + uint32_t extSigZ[5], wordSigZ; + uint_fast8_t carry; + void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * ); + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + expA = expF128UI96( uiA96 ); + uiB96 = bWPtr[indexWordHi( 4 )]; + expB = expF128UI96( uiB96 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return; + uiZ96 = uiA96; + if ( expB == 0x7FFF ) { + uiZ96 = uiB96 ^ packToF128UI96( negateB, 0, 0 ); + if ( (expA == 0x7FFF) && (uiZ96 != uiA96) ) { + softfloat_invalidF128M( zWPtr ); + return; + } + } + zWPtr[indexWordHi( 4 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + return; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signZ = signF128UI96( uiA96 ); + signB = signF128UI96( uiB96 ) ^ negateB; + negateB = (signZ != signB); + if ( (uint32_t) (uiA96<<1) < (uint32_t) (uiB96<<1) ) { + signZ = signB; + expA = expB; + expB = expF128UI96( uiA96 ); + tempPtr = aWPtr; + aWPtr = bWPtr; + bWPtr = tempPtr; + uiA96 = uiB96; + uiB96 = bWPtr[indexWordHi( 4 )]; + } + sig96A = fracF128UI96( uiA96 ); + sig96B = fracF128UI96( uiB96 ); + if ( expA ) { + --expA; + sig96A |= 0x00010000; + if ( expB ) { + --expB; + sig96B |= 0x00010000; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + addCarryMRoutinePtr = + negateB ? softfloat_addComplCarryM : softfloat_addCarryM; + expDiff = expA - expB; + if ( expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + extSigZ[indexWordHi( 5 )] = sig96B; + extSigZ[indexWord( 5, 3 )] = bWPtr[indexWord( 4, 2 )]; + extSigZ[indexWord( 5, 2 )] = bWPtr[indexWord( 4, 1 )]; + extSigZ[indexWord( 5, 1 )] = bWPtr[indexWord( 4, 0 )]; + extSigZ[indexWord( 5, 0 )] = 0; + softfloat_shiftRightJam160M( extSigZ, expDiff, extSigZ ); + sig96B = extSigZ[indexWordHi( 5 )]; + carry = 0; + if ( negateB ) { + sig96B = ~sig96B; + wordSigZ = extSigZ[indexWordLo( 5 )]; + extSigZ[indexWordLo( 5 )] = -wordSigZ; + carry = ! wordSigZ; + } + carry = + (*addCarryMRoutinePtr)( + 3, + &aWPtr[indexMultiwordLo( 4, 3 )], + &extSigZ[indexMultiword( 5, 3, 1 )], + carry, + &extSigZ[indexMultiword( 5, 3, 1 )] + ); + wordSigZ = sig96A + sig96B + carry; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + extSigZ[indexWordLo( 5 )] = 0; + carry = + (*addCarryMRoutinePtr)( + 3, + &aWPtr[indexMultiwordLo( 4, 3 )], + &bWPtr[indexMultiwordLo( 4, 3 )], + negateB, + &extSigZ[indexMultiword( 5, 3, 1 )] + ); + if ( negateB ) { + wordSigZ = sig96A + ~sig96B + carry; + if ( wordSigZ & 0x80000000 ) { + signZ = ! signZ; + carry = + softfloat_addComplCarry96M( + &bWPtr[indexMultiwordLo( 4, 3 )], + &aWPtr[indexMultiwordLo( 4, 3 )], + 1, + &extSigZ[indexMultiword( 5, 3, 1 )] + ); + wordSigZ = sig96B + ~sig96A + carry; + } else { + if ( + ! wordSigZ && ! extSigZ[indexWord( 5, 3 )] + && ! ( extSigZ[indexWord( 5, 2 )] + | extSigZ[indexWord( 5, 1 )] + | extSigZ[indexWord( 5, 0 )] + ) + ) { + signZ = (softfloat_roundingMode == softfloat_round_min); + zWPtr[indexWordHi( 4 )] = packToF128UI96( signZ, 0, 0 ); + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + return; + } + } + } else { + wordSigZ = sig96A + sig96B + carry; + } + } + extSigZ[indexWordHi( 5 )] = wordSigZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundPackRoutinePtr = softfloat_normRoundPackMToF128M; + if ( 0x00010000 <= wordSigZ ) { + if ( 0x00020000 <= wordSigZ ) { + ++expA; + softfloat_shortShiftRightJam160M( extSigZ, 1, extSigZ ); + } + roundPackRoutinePtr = softfloat_roundPackMToF128M; + } + (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addM.c new file mode 100644 index 000000000..c935baaf7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addM.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_addM + +void + softfloat_addM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint32_t *zPtr + ) +{ + unsigned int index, lastIndex; + uint_fast8_t carry; + uint32_t wordA, wordZ; + + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + carry = 0; + for (;;) { + wordA = aPtr[index]; + wordZ = wordA + bPtr[index] + carry; + zPtr[index] = wordZ; + if ( index == lastIndex ) break; + if ( wordZ != wordA ) carry = (wordZ < wordA); + index += wordIncr; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsExtF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsExtF80.c new file mode 100644 index 000000000..b1bb5dbe6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsExtF80.c @@ -0,0 +1,156 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t + softfloat_addMagsExtF80( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0, + bool signZ + ) +{ + int_fast32_t expA; + uint_fast64_t sigA; + int_fast32_t expB; + uint_fast64_t sigB; + int_fast32_t expDiff; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0, sigZ, sigZExtra; + struct exp32_sig64 normExpSig; + int_fast32_t expZ; + struct uint64_extra sig64Extra; + struct uint128 uiZ; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expExtF80UI64( uiA64 ); + sigA = uiA0; + expB = expExtF80UI64( uiB64 ); + sigB = uiB0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( ! expDiff ) { + if ( expA == 0x7FFF ) { + if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + goto propagateNaN; + } + uiZ64 = uiA64; + uiZ0 = uiA0; + goto uiZ; + } + sigZ = sigA + sigB; + sigZExtra = 0; + if ( ! expA ) { + normExpSig = softfloat_normSubnormalExtF80Sig( sigZ ); + expZ = normExpSig.exp + 1; + sigZ = normExpSig.sig; + goto roundAndPack; + } + expZ = expA; + goto shiftRight1; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expDiff < 0 ) { + if ( expB == 0x7FFF ) { + if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + uiZ64 = packToExtF80UI64( signZ, 0x7FFF ); + uiZ0 = uiB0; + goto uiZ; + } + expZ = expB; + if ( ! expA ) { + ++expDiff; + sigZExtra = 0; + if ( ! expDiff ) goto newlyAligned; + } + sig64Extra = softfloat_shiftRightJam64Extra( sigA, 0, -expDiff ); + sigA = sig64Extra.v; + sigZExtra = sig64Extra.extra; + } else { + if ( expA == 0x7FFF ) { + if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + uiZ64 = uiA64; + uiZ0 = uiA0; + goto uiZ; + } + expZ = expA; + if ( ! expB ) { + --expDiff; + sigZExtra = 0; + if ( ! expDiff ) goto newlyAligned; + } + sig64Extra = softfloat_shiftRightJam64Extra( sigB, 0, expDiff ); + sigB = sig64Extra.v; + sigZExtra = sig64Extra.extra; + } + newlyAligned: + sigZ = sigA + sigB; + if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto roundAndPack; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftRight1: + sig64Extra = softfloat_shortShiftRightJam64Extra( sigZ, sigZExtra, 1 ); + sigZ = sig64Extra.v | UINT64_C( 0x8000000000000000 ); + sigZExtra = sig64Extra.extra; + ++expZ; + roundAndPack: + return + softfloat_roundPackToExtF80( + signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF128.c new file mode 100644 index 000000000..8e5ce5b34 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF128.c @@ -0,0 +1,154 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +float128_t + softfloat_addMagsF128( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0, + bool signZ + ) +{ + int_fast32_t expA; + struct uint128 sigA; + int_fast32_t expB; + struct uint128 sigB; + int_fast32_t expDiff; + struct uint128 uiZ, sigZ; + int_fast32_t expZ; + uint_fast64_t sigZExtra; + struct uint128_extra sig128Extra; + union ui128_f128 uZ; + + expA = expF128UI64( uiA64 ); + sigA.v64 = fracF128UI64( uiA64 ); + sigA.v0 = uiA0; + expB = expF128UI64( uiB64 ); + sigB.v64 = fracF128UI64( uiB64 ); + sigB.v0 = uiB0; + expDiff = expA - expB; + if ( ! expDiff ) { + if ( expA == 0x7FFF ) { + if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN; + uiZ.v64 = uiA64; + uiZ.v0 = uiA0; + goto uiZ; + } + sigZ = softfloat_add128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 ); + if ( ! expA ) { + uiZ.v64 = packToF128UI64( signZ, 0, sigZ.v64 ); + uiZ.v0 = sigZ.v0; + goto uiZ; + } + expZ = expA; + sigZ.v64 |= UINT64_C( 0x0002000000000000 ); + sigZExtra = 0; + goto shiftRight1; + } + if ( expDiff < 0 ) { + if ( expB == 0x7FFF ) { + if ( sigB.v64 | sigB.v0 ) goto propagateNaN; + uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 ); + uiZ.v0 = 0; + goto uiZ; + } + expZ = expB; + if ( expA ) { + sigA.v64 |= UINT64_C( 0x0001000000000000 ); + } else { + ++expDiff; + sigZExtra = 0; + if ( ! expDiff ) goto newlyAligned; + } + sig128Extra = + softfloat_shiftRightJam128Extra( sigA.v64, sigA.v0, 0, -expDiff ); + sigA = sig128Extra.v; + sigZExtra = sig128Extra.extra; + } else { + if ( expA == 0x7FFF ) { + if ( sigA.v64 | sigA.v0 ) goto propagateNaN; + uiZ.v64 = uiA64; + uiZ.v0 = uiA0; + goto uiZ; + } + expZ = expA; + if ( expB ) { + sigB.v64 |= UINT64_C( 0x0001000000000000 ); + } else { + --expDiff; + sigZExtra = 0; + if ( ! expDiff ) goto newlyAligned; + } + sig128Extra = + softfloat_shiftRightJam128Extra( sigB.v64, sigB.v0, 0, expDiff ); + sigB = sig128Extra.v; + sigZExtra = sig128Extra.extra; + } + newlyAligned: + sigZ = + softfloat_add128( + sigA.v64 | UINT64_C( 0x0001000000000000 ), + sigA.v0, + sigB.v64, + sigB.v0 + ); + --expZ; + if ( sigZ.v64 < UINT64_C( 0x0002000000000000 ) ) goto roundAndPack; + ++expZ; + shiftRight1: + sig128Extra = + softfloat_shortShiftRightJam128Extra( + sigZ.v64, sigZ.v0, sigZExtra, 1 ); + sigZ = sig128Extra.v; + sigZExtra = sig128Extra.extra; + roundAndPack: + return + softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra ); + propagateNaN: + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF16.c new file mode 100644 index 000000000..b7fba0928 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF16.c @@ -0,0 +1,183 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB ) +{ + int_fast8_t expA; + uint_fast16_t sigA; + int_fast8_t expB; + uint_fast16_t sigB; + int_fast8_t expDiff; + uint_fast16_t uiZ; + bool signZ; + int_fast8_t expZ; + uint_fast16_t sigZ; + uint_fast16_t sigX, sigY; + int_fast8_t shiftDist; + uint_fast32_t sig32Z; + int_fast8_t roundingMode; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expF16UI( uiA ); + sigA = fracF16UI( uiA ); + expB = expF16UI( uiB ); + sigB = fracF16UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( ! expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( ! expA ) { + uiZ = uiA + sigB; + goto uiZ; + } + if ( expA == 0x1F ) { + if ( sigA | sigB ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + signZ = signF16UI( uiA ); + expZ = expA; + sigZ = 0x0800 + sigA + sigB; + if ( ! (sigZ & 1) && (expZ < 0x1E) ) { + sigZ >>= 1; + goto pack; + } + sigZ <<= 3; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + signZ = signF16UI( uiA ); + if ( expDiff < 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + if ( expB == 0x1F ) { + if ( sigB ) goto propagateNaN; + uiZ = packToF16UI( signZ, 0x1F, 0 ); + goto uiZ; + } + if ( expDiff <= -13 ) { + uiZ = packToF16UI( signZ, expB, sigB ); + if ( expA | sigA ) goto addEpsilon; + goto uiZ; + } + expZ = expB; + sigX = sigB | 0x0400; + sigY = sigA + (expA ? 0x0400 : sigA); + shiftDist = 19 + expDiff; + } else { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + uiZ = uiA; + if ( expA == 0x1F ) { + if ( sigA ) goto propagateNaN; + goto uiZ; + } + if ( 13 <= expDiff ) { + if ( expB | sigB ) goto addEpsilon; + goto uiZ; + } + expZ = expA; + sigX = sigA | 0x0400; + sigY = sigB + (expB ? 0x0400 : sigB); + shiftDist = 19 - expDiff; + } + sig32Z = + ((uint_fast32_t) sigX<<19) + ((uint_fast32_t) sigY<>16; + if ( sig32Z & 0xFFFF ) { + sigZ |= 1; + } else { + if ( ! (sigZ & 0xF) && (expZ < 0x1E) ) { + sigZ >>= 4; + goto pack; + } + } + } + return softfloat_roundPackToF16( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF16UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + addEpsilon: + roundingMode = softfloat_roundingMode; + if ( roundingMode != softfloat_round_near_even ) { + if ( + roundingMode + == (signF16UI( uiZ ) ? softfloat_round_min + : softfloat_round_max) + ) { + ++uiZ; + if ( (uint16_t) (uiZ<<1) == 0xF800 ) { + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + } + } +#ifdef SOFTFLOAT_ROUND_ODD + else if ( roundingMode == softfloat_round_odd ) { + uiZ |= 1; + } +#endif + } + softfloat_exceptionFlags |= softfloat_flag_inexact; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + pack: + uiZ = packToF16UI( signZ, expZ, sigZ ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF32.c new file mode 100644 index 000000000..b74489dec --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF32.c @@ -0,0 +1,126 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB ) +{ + int_fast16_t expA; + uint_fast32_t sigA; + int_fast16_t expB; + uint_fast32_t sigB; + int_fast16_t expDiff; + uint_fast32_t uiZ; + bool signZ; + int_fast16_t expZ; + uint_fast32_t sigZ; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( ! expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( ! expA ) { + uiZ = uiA + sigB; + goto uiZ; + } + if ( expA == 0xFF ) { + if ( sigA | sigB ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + signZ = signF32UI( uiA ); + expZ = expA; + sigZ = 0x01000000 + sigA + sigB; + if ( ! (sigZ & 1) && (expZ < 0xFE) ) { + uiZ = packToF32UI( signZ, expZ, sigZ>>1 ); + goto uiZ; + } + sigZ <<= 6; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + signZ = signF32UI( uiA ); + sigA <<= 6; + sigB <<= 6; + if ( expDiff < 0 ) { + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + uiZ = packToF32UI( signZ, 0xFF, 0 ); + goto uiZ; + } + expZ = expB; + sigA += expA ? 0x20000000 : sigA; + sigA = softfloat_shiftRightJam32( sigA, -expDiff ); + } else { + if ( expA == 0xFF ) { + if ( sigA ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + expZ = expA; + sigB += expB ? 0x20000000 : sigB; + sigB = softfloat_shiftRightJam32( sigB, expDiff ); + } + sigZ = 0x20000000 + sigA + sigB; + if ( sigZ < 0x40000000 ) { + --expZ; + sigZ <<= 1; + } + } + return softfloat_roundPackToF32( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF64.c new file mode 100644 index 000000000..e8a489874 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_addMagsF64.c @@ -0,0 +1,128 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +float64_t + softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ ) +{ + int_fast16_t expA; + uint_fast64_t sigA; + int_fast16_t expB; + uint_fast64_t sigB; + int_fast16_t expDiff; + uint_fast64_t uiZ; + int_fast16_t expZ; + uint_fast64_t sigZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( ! expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( ! expA ) { + uiZ = uiA + sigB; + goto uiZ; + } + if ( expA == 0x7FF ) { + if ( sigA | sigB ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + expZ = expA; + sigZ = UINT64_C( 0x0020000000000000 ) + sigA + sigB; + sigZ <<= 9; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sigA <<= 9; + sigB <<= 9; + if ( expDiff < 0 ) { + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + goto uiZ; + } + expZ = expB; + if ( expA ) { + sigA += UINT64_C( 0x2000000000000000 ); + } else { + sigA <<= 1; + } + sigA = softfloat_shiftRightJam64( sigA, -expDiff ); + } else { + if ( expA == 0x7FF ) { + if ( sigA ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + expZ = expA; + if ( expB ) { + sigB += UINT64_C( 0x2000000000000000 ); + } else { + sigB <<= 1; + } + sigB = softfloat_shiftRightJam64( sigB, expDiff ); + } + sigZ = UINT64_C( 0x2000000000000000 ) + sigA + sigB; + if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { + --expZ; + sigZ <<= 1; + } + } + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip32_1.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip32_1.c new file mode 100644 index 000000000..4a326a438 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip32_1.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_approxRecip32_1 + +extern const uint16_t softfloat_approxRecip_1k0s[16]; +extern const uint16_t softfloat_approxRecip_1k1s[16]; + +uint32_t softfloat_approxRecip32_1( uint32_t a ) +{ + int index; + uint16_t eps, r0; + uint32_t sigma0; + uint_fast32_t r; + uint32_t sqrSigma0; + + index = a>>27 & 0xF; + eps = (uint16_t) (a>>11); + r0 = softfloat_approxRecip_1k0s[index] + - ((softfloat_approxRecip_1k1s[index] * (uint_fast32_t) eps)>>20); + sigma0 = ~(uint_fast32_t) ((r0 * (uint_fast64_t) a)>>7); + r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>24); + sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32; + r += ((uint32_t) r * (uint_fast64_t) sqrSigma0)>>48; + return r; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt32_1.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt32_1.c new file mode 100644 index 000000000..b3fdeba68 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt32_1.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_approxRecipSqrt32_1 + +extern const uint16_t softfloat_approxRecipSqrt_1k0s[]; +extern const uint16_t softfloat_approxRecipSqrt_1k1s[]; + +uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a ) +{ + int index; + uint16_t eps, r0; + uint_fast32_t ESqrR0; + uint32_t sigma0; + uint_fast32_t r; + uint32_t sqrSigma0; + + index = (a>>27 & 0xE) + oddExpA; + eps = (uint16_t) (a>>12); + r0 = softfloat_approxRecipSqrt_1k0s[index] + - ((softfloat_approxRecipSqrt_1k1s[index] * (uint_fast32_t) eps) + >>20); + ESqrR0 = (uint_fast32_t) r0 * r0; + if ( ! oddExpA ) ESqrR0 <<= 1; + sigma0 = ~(uint_fast32_t) (((uint32_t) ESqrR0 * (uint_fast64_t) a)>>23); + r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>25); + sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32; + r += ((uint32_t) ((r>>1) + (r>>3) - ((uint_fast32_t) r0<<14)) + * (uint_fast64_t) sqrSigma0) + >>48; + if ( ! (r & 0x80000000) ) r = 0x80000000; + return r; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt_1Ks.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt_1Ks.c new file mode 100644 index 000000000..38a27985c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecipSqrt_1Ks.c @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" + +const uint16_t softfloat_approxRecipSqrt_1k0s[16] = { + 0xB4C9, 0xFFAB, 0xAA7D, 0xF11C, 0xA1C5, 0xE4C7, 0x9A43, 0xDA29, + 0x93B5, 0xD0E5, 0x8DED, 0xC8B7, 0x88C6, 0xC16D, 0x8424, 0xBAE1 +}; +const uint16_t softfloat_approxRecipSqrt_1k1s[16] = { + 0xA5A5, 0xEA42, 0x8C21, 0xC62D, 0x788F, 0xAA7F, 0x6928, 0x94B6, + 0x5CC7, 0x8335, 0x52A6, 0x74E2, 0x4A3E, 0x68FE, 0x432B, 0x5EFD +}; + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip_1Ks.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip_1Ks.c new file mode 100644 index 000000000..f1fca74e7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_approxRecip_1Ks.c @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" + +const uint16_t softfloat_approxRecip_1k0s[16] = { + 0xFFC4, 0xF0BE, 0xE363, 0xD76F, 0xCCAD, 0xC2F0, 0xBA16, 0xB201, + 0xAA97, 0xA3C6, 0x9D7A, 0x97A6, 0x923C, 0x8D32, 0x887E, 0x8417 +}; +const uint16_t softfloat_approxRecip_1k1s[16] = { + 0xF0F1, 0xD62C, 0xBFA1, 0xAC77, 0x9C0A, 0x8DDB, 0x8185, 0x76BA, + 0x6D3B, 0x64D4, 0x5D5C, 0x56B1, 0x50B6, 0x4B55, 0x4679, 0x4211 +}; + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare128M.c new file mode 100644 index 000000000..dc97ce9e5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare128M.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_compare128M + +int_fast8_t softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr ) +{ + unsigned int index, lastIndex; + uint32_t wordA, wordB; + + index = indexWordHi( 4 ); + lastIndex = indexWordLo( 4 ); + for (;;) { + wordA = aPtr[index]; + wordB = bPtr[index]; + if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1; + if ( index == lastIndex ) break; + index -= wordIncr; + } + return 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare96M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare96M.c new file mode 100644 index 000000000..2681c4627 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compare96M.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_compare96M + +int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr ) +{ + unsigned int index, lastIndex; + uint32_t wordA, wordB; + + index = indexWordHi( 3 ); + lastIndex = indexWordLo( 3 ); + for (;;) { + wordA = aPtr[index]; + wordB = bPtr[index]; + if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1; + if ( index == lastIndex ) break; + index -= wordIncr; + } + return 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compareNonnormExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compareNonnormExtF80M.c new file mode 100644 index 000000000..267315304 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_compareNonnormExtF80M.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat_types.h" + +int + softfloat_compareNonnormExtF80M( + const struct extFloat80M *aSPtr, const struct extFloat80M *bSPtr ) +{ + uint_fast16_t uiA64, uiB64; + uint64_t sigA; + bool signB; + uint64_t sigB; + int32_t expA, expB; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA64 = aSPtr->signExp; + uiB64 = bSPtr->signExp; + sigA = aSPtr->signif; + signB = signExtF80UI64( uiB64 ); + sigB = bSPtr->signif; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( (uiA64 ^ uiB64) & 0x8000 ) { + if ( ! (sigA | sigB) ) return 0; + goto resultFromSignB; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expExtF80UI64( uiA64 ); + expB = expExtF80UI64( uiB64 ); + if ( expA == 0x7FFF ) { + if (expB == 0x7FFF) return 0; + signB = ! signB; + goto resultFromSignB; + } + if ( expB == 0x7FFF ) { + goto resultFromSignB; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) expA = 1; + if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) { + if ( sigA ) { + expA += softfloat_normExtF80SigM( &sigA ); + } else { + expA = -128; + } + } + if ( ! expB ) expB = 1; + if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) { + if ( sigB ) { + expB += softfloat_normExtF80SigM( &sigB ); + } else { + expB = -128; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signB ) { + if ( expA < expB ) return 1; + if ( (expB < expA) || (sigB < sigA) ) return -1; + } else { + if ( expB < expA ) return 1; + if ( (expA < expB) || (sigA < sigB) ) return -1; + } + return (sigA != sigB); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + resultFromSignB: + return signB ? 1 : -1; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros16.c new file mode 100644 index 000000000..7a68da52f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros16.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_countLeadingZeros16 + +#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16 +#include "primitives.h" + +uint_fast8_t softfloat_countLeadingZeros16( uint16_t a ) +{ + uint_fast8_t count; + + count = 8; + if ( 0x100 <= a ) { + count = 0; + a >>= 8; + } + count += softfloat_countLeadingZeros8[a]; + return count; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros32.c new file mode 100644 index 000000000..53ab22824 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros32.c @@ -0,0 +1,64 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_countLeadingZeros32 + +#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32 +#include "primitives.h" + +uint_fast8_t softfloat_countLeadingZeros32( uint32_t a ) +{ + uint_fast8_t count; + + count = 0; + if ( a < 0x10000 ) { + count = 16; + a <<= 16; + } + if ( a < 0x1000000 ) { + count += 8; + a <<= 8; + } + count += softfloat_countLeadingZeros8[a>>24]; + return count; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros64.c new file mode 100644 index 000000000..13a222463 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros64.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_countLeadingZeros64 + +#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64 +#include "primitives.h" + +uint_fast8_t softfloat_countLeadingZeros64( uint64_t a ) +{ + uint_fast8_t count; + uint32_t a32; + + count = 0; + a32 = a>>32; + if ( ! a32 ) { + count = 32; + a32 = a; + } + /*------------------------------------------------------------------------ + | From here, result is current count + count leading zeros of `a32'. + *------------------------------------------------------------------------*/ + if ( a32 < 0x10000 ) { + count += 16; + a32 <<= 16; + } + if ( a32 < 0x1000000 ) { + count += 8; + a32 <<= 8; + } + count += softfloat_countLeadingZeros8[a32>>24]; + return count; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros8.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros8.c new file mode 100644 index 000000000..a56f5a40c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_countLeadingZeros8.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" + +const uint_least8_t softfloat_countLeadingZeros8[256] = { + 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_eq128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_eq128.c new file mode 100644 index 000000000..275b8ae29 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_eq128.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" + +#ifndef softfloat_eq128 + +bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + + return (a64 == b64) && (a0 == b0); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidExtF80M.c new file mode 100644 index 000000000..237d21721 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidExtF80M.c @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +void softfloat_invalidExtF80M( struct extFloat80M *zSPtr ) +{ + + softfloat_raiseFlags( softfloat_flag_invalid ); + zSPtr->signExp = defaultNaNExtF80UI64; + zSPtr->signif = defaultNaNExtF80UI0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidF128M.c new file mode 100644 index 000000000..a20840e5f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_invalidF128M.c @@ -0,0 +1,53 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitives.h" +#include "specialize.h" +#include "softfloat.h" + +void softfloat_invalidF128M( uint32_t *zWPtr ) +{ + + softfloat_raiseFlags( softfloat_flag_invalid ); + zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96; + zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64; + zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32; + zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_isNaNF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_isNaNF128M.c new file mode 100644 index 000000000..6008cf3eb --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_isNaNF128M.c @@ -0,0 +1,57 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "primitives.h" + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +bool softfloat_isNaNF128M( const uint32_t *aWPtr ) +{ + uint32_t uiA96; + + uiA96 = aWPtr[indexWordHi( 4 )]; + if ( (~uiA96 & 0x7FFF0000) != 0 ) return false; + return + ((uiA96 & 0x0000FFFF) != 0) + || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )] + | aWPtr[indexWord( 4, 0 )]) + != 0); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_le128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_le128.c new file mode 100644 index 000000000..1fce7af98 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_le128.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" + +#ifndef softfloat_le128 + +bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + + return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_lt128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_lt128.c new file mode 100644 index 000000000..d7ce3b997 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_lt128.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" + +#ifndef softfloat_lt128 + +bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + + return (a64 < b64) || ((a64 == b64) && (a0 < b0)); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128By32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128By32.c new file mode 100644 index 000000000..7c0fdc867 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128By32.c @@ -0,0 +1,58 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_mul128By32 + +struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b ) +{ + struct uint128 z; + uint_fast64_t mid; + uint_fast32_t carry; + + z.v0 = a0 * b; + mid = (uint_fast64_t) (uint32_t) (a0>>32) * b; + carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid); + z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128MTo256M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128MTo256M.c new file mode 100644 index 000000000..ea8865ea3 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128MTo256M.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_mul128MTo256M + +void + softfloat_mul128MTo256M( + const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr ) +{ + uint32_t *lastZPtr, wordB; + uint64_t dwordProd; + uint32_t wordZ; + uint_fast8_t carry; + + bPtr += indexWordLo( 4 ); + lastZPtr = zPtr + indexMultiwordHi( 8, 5 ); + zPtr += indexMultiwordLo( 8, 5 ); + wordB = *bPtr; + dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB; + zPtr[indexWord( 5, 0 )] = dwordProd; + dwordProd = (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32); + zPtr[indexWord( 5, 1 )] = dwordProd; + dwordProd = (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32); + zPtr[indexWord( 5, 2 )] = dwordProd; + dwordProd = (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32); + zPtr[indexWord( 5, 3 )] = dwordProd; + zPtr[indexWord( 5, 4 )] = dwordProd>>32; + do { + bPtr += wordIncr; + zPtr += wordIncr; + wordB = *bPtr; + dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB; + wordZ = zPtr[indexWord( 5, 0 )] + (uint32_t) dwordProd; + zPtr[indexWord( 5, 0 )] = wordZ; + carry = (wordZ < (uint32_t) dwordProd); + dwordProd = + (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32); + wordZ = zPtr[indexWord( 5, 1 )] + (uint32_t) dwordProd + carry; + zPtr[indexWord( 5, 1 )] = wordZ; + if ( wordZ != (uint32_t) dwordProd ) { + carry = (wordZ < (uint32_t) dwordProd); + } + dwordProd = + (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32); + wordZ = zPtr[indexWord( 5, 2 )] + (uint32_t) dwordProd + carry; + zPtr[indexWord( 5, 2 )] = wordZ; + if ( wordZ != (uint32_t) dwordProd ) { + carry = (wordZ < (uint32_t) dwordProd); + } + dwordProd = + (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32); + wordZ = zPtr[indexWord( 5, 3 )] + (uint32_t) dwordProd + carry; + zPtr[indexWord( 5, 3 )] = wordZ; + if ( wordZ != (uint32_t) dwordProd ) { + carry = (wordZ < (uint32_t) dwordProd); + } + zPtr[indexWord( 5, 4 )] = (dwordProd>>32) + carry; + } while ( zPtr != lastZPtr ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128To256M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128To256M.c new file mode 100644 index 000000000..7c9d9b584 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul128To256M.c @@ -0,0 +1,71 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_mul128To256M + +#define softfloat_mul128To256M softfloat_mul128To256M +#include "primitives.h" + +void + softfloat_mul128To256M( + uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr ) +{ + struct uint128 p0, p64, p128; + uint_fast64_t z64, z128, z192; + + p0 = softfloat_mul64To128( a0, b0 ); + zPtr[indexWord( 4, 0 )] = p0.v0; + p64 = softfloat_mul64To128( a64, b0 ); + z64 = p64.v0 + p0.v64; + z128 = p64.v64 + (z64 < p64.v0); + p128 = softfloat_mul64To128( a64, b64 ); + z128 += p128.v0; + z192 = p128.v64 + (z128 < p128.v0); + p64 = softfloat_mul64To128( a0, b64 ); + z64 += p64.v0; + zPtr[indexWord( 4, 1 )] = z64; + p64.v64 += (z64 < p64.v0); + z128 += p64.v64; + zPtr[indexWord( 4, 2 )] = z128; + zPtr[indexWord( 4, 3 )] = z192 + (z128 < p64.v64); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64ByShifted32To128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64ByShifted32To128.c new file mode 100644 index 000000000..57e528888 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64ByShifted32To128.c @@ -0,0 +1,56 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_mul64ByShifted32To128 + +struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b ) +{ + uint_fast64_t mid; + struct uint128 z; + + mid = (uint_fast64_t) (uint32_t) a * b; + z.v0 = mid<<32; + z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128.c new file mode 100644 index 000000000..5d360aa4b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128.c @@ -0,0 +1,66 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_mul64To128 + +struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b ) +{ + uint32_t a32, a0, b32, b0; + struct uint128 z; + uint64_t mid1, mid; + + a32 = a>>32; + a0 = a; + b32 = b>>32; + b0 = b; + z.v0 = (uint_fast64_t) a0 * b0; + mid1 = (uint_fast64_t) a32 * b0; + mid = mid1 + (uint_fast64_t) a0 * b32; + z.v64 = (uint_fast64_t) a32 * b32; + z.v64 += (uint_fast64_t) (mid < mid1)<<32 | mid>>32; + mid <<= 32; + z.v0 += mid; + z.v64 += (z.v0 < mid); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128M.c new file mode 100644 index 000000000..ed10be324 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mul64To128M.c @@ -0,0 +1,68 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_mul64To128M + +void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr ) +{ + uint32_t a32, a0, b32, b0; + uint64_t z0, mid1, z64, mid; + + a32 = a>>32; + a0 = a; + b32 = b>>32; + b0 = b; + z0 = (uint64_t) a0 * b0; + mid1 = (uint64_t) a32 * b0; + mid = mid1 + (uint64_t) a0 * b32; + z64 = (uint64_t) a32 * b32; + z64 += (uint64_t) (mid < mid1)<<32 | mid>>32; + mid <<= 32; + z0 += mid; + zPtr[indexWord( 4, 1 )] = z0>>32; + zPtr[indexWord( 4, 0 )] = z0; + z64 += (z0 < mid); + zPtr[indexWord( 4, 3 )] = z64>>32; + zPtr[indexWord( 4, 2 )] = z64; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128.c new file mode 100644 index 000000000..f6b2b45df --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128.c @@ -0,0 +1,350 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t + softfloat_mulAddF128( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0, + uint_fast64_t uiC64, + uint_fast64_t uiC0, + uint_fast8_t op + ) +{ + bool signA; + int_fast32_t expA; + struct uint128 sigA; + bool signB; + int_fast32_t expB; + struct uint128 sigB; + bool signC; + int_fast32_t expC; + struct uint128 sigC; + bool signZ; + uint_fast64_t magBits; + struct uint128 uiZ; + struct exp32_sig128 normExpSig; + int_fast32_t expZ; + uint64_t sig256Z[4]; + struct uint128 sigZ; + int_fast32_t shiftDist, expDiff; + struct uint128 x128; + uint64_t sig256C[4]; + static uint64_t zero256[4] = INIT_UINTM4( 0, 0, 0, 0 ); + uint_fast64_t sigZExtra, sig256Z0; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signF128UI64( uiA64 ); + expA = expF128UI64( uiA64 ); + sigA.v64 = fracF128UI64( uiA64 ); + sigA.v0 = uiA0; + signB = signF128UI64( uiB64 ); + expB = expF128UI64( uiB64 ); + sigB.v64 = fracF128UI64( uiB64 ); + sigB.v0 = uiB0; + signC = signF128UI64( uiC64 ) ^ (op == softfloat_mulAdd_subC); + expC = expF128UI64( uiC64 ); + sigC.v64 = fracF128UI64( uiC64 ); + sigC.v0 = uiC0; + signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FFF ) { + if ( + (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0)) + ) { + goto propagateNaN_ABC; + } + magBits = expB | sigB.v64 | sigB.v0; + goto infProdArg; + } + if ( expB == 0x7FFF ) { + if ( sigB.v64 | sigB.v0 ) goto propagateNaN_ABC; + magBits = expA | sigA.v64 | sigA.v0; + goto infProdArg; + } + if ( expC == 0x7FFF ) { + if ( sigC.v64 | sigC.v0 ) { + uiZ.v64 = 0; + uiZ.v0 = 0; + goto propagateNaN_ZC; + } + uiZ.v64 = uiC64; + uiZ.v0 = uiC0; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! (sigA.v64 | sigA.v0) ) goto zeroProd; + normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! (sigB.v64 | sigB.v0) ) goto zeroProd; + normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x3FFE; + sigA.v64 |= UINT64_C( 0x0001000000000000 ); + sigB.v64 |= UINT64_C( 0x0001000000000000 ); + sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 8 ); + sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 15 ); + softfloat_mul128To256M( sigA.v64, sigA.v0, sigB.v64, sigB.v0, sig256Z ); + sigZ.v64 = sig256Z[indexWord( 4, 3 )]; + sigZ.v0 = sig256Z[indexWord( 4, 2 )]; + shiftDist = 0; + if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) { + --expZ; + shiftDist = -1; + } + if ( ! expC ) { + if ( ! (sigC.v64 | sigC.v0) ) { + shiftDist += 8; + goto sigZ; + } + normExpSig = softfloat_normSubnormalF128Sig( sigC.v64, sigC.v0 ); + expC = normExpSig.exp; + sigC = normExpSig.sig; + } + sigC.v64 |= UINT64_C( 0x0001000000000000 ); + sigC = softfloat_shortShiftLeft128( sigC.v64, sigC.v0, 8 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expZ - expC; + if ( expDiff < 0 ) { + expZ = expC; + if ( (signZ == signC) || (expDiff < -1) ) { + shiftDist -= expDiff; + if ( shiftDist ) { + sigZ = + softfloat_shiftRightJam128( sigZ.v64, sigZ.v0, shiftDist ); + } + } else { + if ( ! shiftDist ) { + x128 = + softfloat_shortShiftRight128( + sig256Z[indexWord( 4, 1 )], sig256Z[indexWord( 4, 0 )], + 1 + ); + sig256Z[indexWord( 4, 1 )] = (sigZ.v0<<63) | x128.v64; + sig256Z[indexWord( 4, 0 )] = x128.v0; + sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, 1 ); + sig256Z[indexWord( 4, 3 )] = sigZ.v64; + sig256Z[indexWord( 4, 2 )] = sigZ.v0; + } + } + } else { + if ( shiftDist ) softfloat_add256M( sig256Z, sig256Z, sig256Z ); + if ( ! expDiff ) { + sigZ.v64 = sig256Z[indexWord( 4, 3 )]; + sigZ.v0 = sig256Z[indexWord( 4, 2 )]; + } else { + sig256C[indexWord( 4, 3 )] = sigC.v64; + sig256C[indexWord( 4, 2 )] = sigC.v0; + sig256C[indexWord( 4, 1 )] = 0; + sig256C[indexWord( 4, 0 )] = 0; + softfloat_shiftRightJam256M( sig256C, expDiff, sig256C ); + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + shiftDist = 8; + if ( signZ == signC ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff <= 0 ) { + sigZ = softfloat_add128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 ); + } else { + softfloat_add256M( sig256Z, sig256C, sig256Z ); + sigZ.v64 = sig256Z[indexWord( 4, 3 )]; + sigZ.v0 = sig256Z[indexWord( 4, 2 )]; + } + if ( sigZ.v64 & UINT64_C( 0x0200000000000000 ) ) { + ++expZ; + shiftDist = 9; + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff < 0 ) { + signZ = signC; + if ( expDiff < -1 ) { + sigZ = + softfloat_sub128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 ); + sigZExtra = + sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )]; + if ( sigZExtra ) { + sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, 0, 1 ); + } + if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) { + --expZ; + shiftDist = 7; + } + goto shiftRightRoundPack; + } else { + sig256C[indexWord( 4, 3 )] = sigC.v64; + sig256C[indexWord( 4, 2 )] = sigC.v0; + sig256C[indexWord( 4, 1 )] = 0; + sig256C[indexWord( 4, 0 )] = 0; + softfloat_sub256M( sig256C, sig256Z, sig256Z ); + } + } else if ( ! expDiff ) { + sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, sigC.v64, sigC.v0 ); + if ( + ! (sigZ.v64 | sigZ.v0) && ! sig256Z[indexWord( 4, 1 )] + && ! sig256Z[indexWord( 4, 0 )] + ) { + goto completeCancellation; + } + sig256Z[indexWord( 4, 3 )] = sigZ.v64; + sig256Z[indexWord( 4, 2 )] = sigZ.v0; + if ( sigZ.v64 & UINT64_C( 0x8000000000000000 ) ) { + signZ = ! signZ; + softfloat_sub256M( zero256, sig256Z, sig256Z ); + } + } else { + softfloat_sub256M( sig256Z, sig256C, sig256Z ); + if ( 1 < expDiff ) { + sigZ.v64 = sig256Z[indexWord( 4, 3 )]; + sigZ.v0 = sig256Z[indexWord( 4, 2 )]; + if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) { + --expZ; + shiftDist = 7; + } + goto sigZ; + } + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sigZ.v64 = sig256Z[indexWord( 4, 3 )]; + sigZ.v0 = sig256Z[indexWord( 4, 2 )]; + sigZExtra = sig256Z[indexWord( 4, 1 )]; + sig256Z0 = sig256Z[indexWord( 4, 0 )]; + if ( sigZ.v64 ) { + if ( sig256Z0 ) sigZExtra |= 1; + } else { + expZ -= 64; + sigZ.v64 = sigZ.v0; + sigZ.v0 = sigZExtra; + sigZExtra = sig256Z0; + if ( ! sigZ.v64 ) { + expZ -= 64; + sigZ.v64 = sigZ.v0; + sigZ.v0 = sigZExtra; + sigZExtra = 0; + if ( ! sigZ.v64 ) { + expZ -= 64; + sigZ.v64 = sigZ.v0; + sigZ.v0 = 0; + } + } + } + shiftDist = softfloat_countLeadingZeros64( sigZ.v64 ); + expZ += 7 - shiftDist; + shiftDist = 15 - shiftDist; + if ( 0 < shiftDist ) goto shiftRightRoundPack; + if ( shiftDist ) { + shiftDist = -shiftDist; + sigZ = softfloat_shortShiftLeft128( sigZ.v64, sigZ.v0, shiftDist ); + x128 = softfloat_shortShiftLeft128( 0, sigZExtra, shiftDist ); + sigZ.v0 |= x128.v64; + sigZExtra = x128.v0; + } + goto roundPack; + } + sigZ: + sigZExtra = sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )]; + shiftRightRoundPack: + sigZExtra = (uint64_t) (sigZ.v0<<(64 - shiftDist)) | (sigZExtra != 0); + sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, shiftDist ); + roundPack: + return + softfloat_roundPackToF128( + signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN_ABC: + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 ); + goto propagateNaN_ZC; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infProdArg: + if ( magBits ) { + uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 ); + uiZ.v0 = 0; + if ( expC != 0x7FFF ) goto uiZ; + if ( sigC.v64 | sigC.v0 ) goto propagateNaN_ZC; + if ( signZ == signC ) goto uiZ; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + propagateNaN_ZC: + uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zeroProd: + uiZ.v64 = uiC64; + uiZ.v0 = uiC0; + if ( ! (expC | sigC.v64 | sigC.v0) && (signZ != signC) ) { + completeCancellation: + uiZ.v64 = + packToF128UI64( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + uiZ.v0 = 0; + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128M.c new file mode 100644 index 000000000..f51fc71d2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF128M.c @@ -0,0 +1,382 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +void + softfloat_mulAddF128M( + const uint32_t *aWPtr, + const uint32_t *bWPtr, + const uint32_t *cWPtr, + uint32_t *zWPtr, + uint_fast8_t op + ) +{ + uint32_t uiA96; + int32_t expA; + uint32_t uiB96; + int32_t expB; + uint32_t uiC96; + bool signC; + int32_t expC; + bool signProd, prodIsInfinite; + uint32_t *ptr, uiZ96, sigA[4]; + uint_fast8_t shiftDist; + uint32_t sigX[5]; + int32_t expProd; + uint32_t sigProd[8], wordSig; + bool doSub; + uint_fast8_t + (*addCarryMRoutinePtr)( + uint_fast8_t, + const uint32_t *, + const uint32_t *, + uint_fast8_t, + uint32_t * + ); + int32_t expDiff; + bool signZ; + int32_t expZ; + uint32_t *extSigPtr; + uint_fast8_t carry; + void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * ); + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uiA96 = aWPtr[indexWordHi( 4 )]; + expA = expF128UI96( uiA96 ); + uiB96 = bWPtr[indexWordHi( 4 )]; + expB = expF128UI96( uiB96 ); + uiC96 = cWPtr[indexWordHi( 4 )]; + signC = signF128UI96( uiC96 ) ^ (op == softfloat_mulAdd_subC); + expC = expF128UI96( uiC96 ); + signProd = + signF128UI96( uiA96 ) ^ signF128UI96( uiB96 ) + ^ (op == softfloat_mulAdd_subProd); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + prodIsInfinite = false; + if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) { + if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) { + goto propagateNaN_ZC; + } + ptr = (uint32_t *) aWPtr; + if ( ! (uint32_t) (uiA96<<1) ) goto possibleInvalidProd; + if ( ! (uint32_t) (uiB96<<1) ) { + ptr = (uint32_t *) bWPtr; + possibleInvalidProd: + if ( + ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )] + | ptr[indexWord( 4, 0 )]) + ) { + goto invalid; + } + } + prodIsInfinite = true; + } + if ( expC == 0x7FFF ) { + if ( + fracF128UI96( uiC96 ) + || (cWPtr[indexWord( 4, 2 )] | cWPtr[indexWord( 4, 1 )] + | cWPtr[indexWord( 4, 0 )]) + ) { + zWPtr[indexWordHi( 4 )] = 0; + goto propagateNaN_ZC; + } + if ( prodIsInfinite && (signProd != signC) ) goto invalid; + goto copyC; + } + if ( prodIsInfinite ) { + uiZ96 = packToF128UI96( signProd, 0x7FFF, 0 ); + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA ) { + sigA[indexWordHi( 4 )] = fracF128UI96( uiA96 ) | 0x00010000; + sigA[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )]; + sigA[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )]; + sigA[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )]; + } else { + expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA ); + if ( expA == -128 ) goto zeroProd; + } + if ( expB ) { + sigX[indexWordHi( 4 )] = fracF128UI96( uiB96 ) | 0x00010000; + sigX[indexWord( 4, 2 )] = bWPtr[indexWord( 4, 2 )]; + sigX[indexWord( 4, 1 )] = bWPtr[indexWord( 4, 1 )]; + sigX[indexWord( 4, 0 )] = bWPtr[indexWord( 4, 0 )]; + } else { + expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigX ); + if ( expB == -128 ) goto zeroProd; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expProd = expA + expB - 0x3FF0; + softfloat_mul128MTo256M( sigA, sigX, sigProd ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + wordSig = fracF128UI96( uiC96 ); + if ( expC ) { + --expC; + wordSig |= 0x00010000; + } + sigX[indexWordHi( 5 )] = wordSig; + sigX[indexWord( 5, 3 )] = cWPtr[indexWord( 4, 2 )]; + sigX[indexWord( 5, 2 )] = cWPtr[indexWord( 4, 1 )]; + sigX[indexWord( 5, 1 )] = cWPtr[indexWord( 4, 0 )]; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + doSub = (signProd != signC); + addCarryMRoutinePtr = + doSub ? softfloat_addComplCarryM : softfloat_addCarryM; + expDiff = expProd - expC; + if ( expDiff <= 0 ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + signZ = signC; + expZ = expC; + if ( + sigProd[indexWord( 8, 2 )] + || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )]) + ) { + sigProd[indexWord( 8, 3 )] |= 1; + } + extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )]; + if ( expDiff ) { + softfloat_shiftRightJam160M( extSigPtr, -expDiff, extSigPtr ); + } + carry = 0; + if ( doSub ) { + wordSig = extSigPtr[indexWordLo( 5 )]; + extSigPtr[indexWordLo( 5 )] = -wordSig; + carry = ! wordSig; + } + (*addCarryMRoutinePtr)( + 4, + &sigX[indexMultiwordHi( 5, 4 )], + extSigPtr + indexMultiwordHi( 5, 4 ), + carry, + extSigPtr + indexMultiwordHi( 5, 4 ) + ); + wordSig = extSigPtr[indexWordHi( 5 )]; + if ( ! expZ ) { + if ( wordSig & 0x80000000 ) { + signZ = ! signZ; + softfloat_negX160M( extSigPtr ); + wordSig = extSigPtr[indexWordHi( 5 )]; + } + goto checkCancellation; + } + if ( wordSig < 0x00010000 ) { + --expZ; + softfloat_add160M( extSigPtr, extSigPtr, extSigPtr ); + goto roundPack; + } + goto extSigReady_noCancellation; + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + signZ = signProd; + expZ = expProd; + sigX[indexWordLo( 5 )] = 0; + expDiff -= 128; + if ( 0 <= expDiff ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + if ( expDiff ) softfloat_shiftRightJam160M( sigX, expDiff, sigX ); + wordSig = sigX[indexWordLo( 5 )]; + carry = 0; + if ( doSub ) { + carry = ! wordSig; + wordSig = -wordSig; + } + carry = + (*addCarryMRoutinePtr)( + 4, + &sigProd[indexMultiwordLo( 8, 4 )], + &sigX[indexMultiwordHi( 5, 4 )], + carry, + &sigProd[indexMultiwordLo( 8, 4 )] + ); + sigProd[indexWord( 8, 2 )] |= wordSig; + ptr = &sigProd[indexWord( 8, 4 )]; + } else { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + shiftDist = expDiff & 31; + if ( shiftDist ) { + softfloat_shortShiftRight160M( sigX, shiftDist, sigX ); + } + expDiff >>= 5; + extSigPtr = + &sigProd[indexMultiwordLo( 8, 5 )] - wordIncr + + expDiff * -wordIncr; + carry = + (*addCarryMRoutinePtr)( 5, extSigPtr, sigX, doSub, extSigPtr ); + if ( expDiff == -4 ) { + /*------------------------------------------------------------ + *------------------------------------------------------------*/ + wordSig = sigProd[indexWordHi( 8 )]; + if ( wordSig & 0x80000000 ) { + signZ = ! signZ; + softfloat_negX256M( sigProd ); + wordSig = sigProd[indexWordHi( 8 )]; + } + /*------------------------------------------------------------ + *------------------------------------------------------------*/ + if ( wordSig ) goto expProdBigger_noWordShift; + wordSig = sigProd[indexWord( 8, 6 )]; + if ( 0x00040000 <= wordSig ) goto expProdBigger_noWordShift; + expZ -= 32; + extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )] - wordIncr; + for (;;) { + if ( wordSig ) break; + wordSig = extSigPtr[indexWord( 5, 3 )]; + if ( 0x00040000 <= wordSig ) break; + expZ -= 32; + extSigPtr -= wordIncr; + if ( extSigPtr == &sigProd[indexMultiwordLo( 8, 5 )] ) { + goto checkCancellation; + } + } + /*------------------------------------------------------------ + *------------------------------------------------------------*/ + ptr = extSigPtr + indexWordLo( 5 ); + do { + ptr -= wordIncr; + if ( *ptr ) { + extSigPtr[indexWordLo( 5 )] |= 1; + break; + } + } while ( ptr != &sigProd[indexWordLo( 8 )] ); + wordSig = extSigPtr[indexWordHi( 5 )]; + goto extSigReady; + } + ptr = extSigPtr + indexWordHi( 5 ) + wordIncr; + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( carry != doSub ) { + if ( doSub ) { + do { + wordSig = *ptr; + *ptr = wordSig - 1; + ptr += wordIncr; + } while ( ! wordSig ); + } else { + do { + wordSig = *ptr + 1; + *ptr = wordSig; + ptr += wordIncr; + } while ( ! wordSig ); + } + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + expProdBigger_noWordShift: + if ( + sigProd[indexWord( 8, 2 )] + || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )]) + ) { + sigProd[indexWord( 8, 3 )] |= 1; + } + extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )]; + wordSig = extSigPtr[indexWordHi( 5 )]; + } + extSigReady: + roundPackRoutinePtr = softfloat_normRoundPackMToF128M; + if ( wordSig < 0x00010000 ) goto doRoundPack; + extSigReady_noCancellation: + if ( 0x00020000 <= wordSig ) { + ++expZ; + softfloat_shortShiftRightJam160M( extSigPtr, 1, extSigPtr ); + } + roundPack: + roundPackRoutinePtr = softfloat_roundPackMToF128M; + doRoundPack: + (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_invalidF128M( zWPtr ); + propagateNaN_ZC: + softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr ); + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zeroProd: + if ( + ! (uint32_t) (uiC96<<1) && (signProd != signC) + && ! cWPtr[indexWord( 4, 2 )] + && ! (cWPtr[indexWord( 4, 1 )] | cWPtr[indexWord( 4, 0 )]) + ) { + goto completeCancellation; + } + copyC: + zWPtr[indexWordHi( 4 )] = uiC96; + zWPtr[indexWord( 4, 2 )] = cWPtr[indexWord( 4, 2 )]; + zWPtr[indexWord( 4, 1 )] = cWPtr[indexWord( 4, 1 )]; + zWPtr[indexWord( 4, 0 )] = cWPtr[indexWord( 4, 0 )]; + return; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + checkCancellation: + if ( + wordSig + || (extSigPtr[indexWord( 5, 3 )] | extSigPtr[indexWord( 5, 2 )]) + || (extSigPtr[indexWord( 5, 1 )] | extSigPtr[indexWord( 5, 0 )]) + ) { + goto extSigReady; + } + completeCancellation: + uiZ96 = + packToF128UI96( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + uiZ: + zWPtr[indexWordHi( 4 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF16.c new file mode 100644 index 000000000..3a684ac32 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_mulAddF16.c @@ -0,0 +1,226 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t + softfloat_mulAddF16( + uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op ) +{ + bool signA; + int_fast8_t expA; + uint_fast16_t sigA; + bool signB; + int_fast8_t expB; + uint_fast16_t sigB; + bool signC; + int_fast8_t expC; + uint_fast16_t sigC; + bool signProd; + uint_fast16_t magBits, uiZ; + struct exp8_sig16 normExpSig; + int_fast8_t expProd; + uint_fast32_t sigProd; + bool signZ; + int_fast8_t expZ; + uint_fast16_t sigZ; + int_fast8_t expDiff; + uint_fast32_t sig32Z, sig32C; + int_fast8_t shiftDist; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signF16UI( uiA ); + expA = expF16UI( uiA ); + sigA = fracF16UI( uiA ); + signB = signF16UI( uiB ); + expB = expF16UI( uiB ); + sigB = fracF16UI( uiB ); + signC = signF16UI( uiC ) ^ (op == softfloat_mulAdd_subC); + expC = expF16UI( uiC ); + sigC = fracF16UI( uiC ); + signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x1F ) { + if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN_ABC; + magBits = expB | sigB; + goto infProdArg; + } + if ( expB == 0x1F ) { + if ( sigB ) goto propagateNaN_ABC; + magBits = expA | sigA; + goto infProdArg; + } + if ( expC == 0x1F ) { + if ( sigC ) { + uiZ = 0; + goto propagateNaN_ZC; + } + uiZ = uiC; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) goto zeroProd; + normExpSig = softfloat_normSubnormalF16Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zeroProd; + normExpSig = softfloat_normSubnormalF16Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expProd = expA + expB - 0xE; + sigA = (sigA | 0x0400)<<4; + sigB = (sigB | 0x0400)<<4; + sigProd = (uint_fast32_t) sigA * sigB; + if ( sigProd < 0x20000000 ) { + --expProd; + sigProd <<= 1; + } + signZ = signProd; + if ( ! expC ) { + if ( ! sigC ) { + expZ = expProd - 1; + sigZ = sigProd>>15 | ((sigProd & 0x7FFF) != 0); + goto roundPack; + } + normExpSig = softfloat_normSubnormalF16Sig( sigC ); + expC = normExpSig.exp; + sigC = normExpSig.sig; + } + sigC = (sigC | 0x0400)<<3; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expProd - expC; + if ( signProd == signC ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff <= 0 ) { + expZ = expC; + sigZ = sigC + softfloat_shiftRightJam32( sigProd, 16 - expDiff ); + } else { + expZ = expProd; + sig32Z = + sigProd + + softfloat_shiftRightJam32( + (uint_fast32_t) sigC<<16, expDiff ); + sigZ = sig32Z>>16 | ((sig32Z & 0xFFFF) != 0 ); + } + if ( sigZ < 0x4000 ) { + --expZ; + sigZ <<= 1; + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig32C = (uint_fast32_t) sigC<<16; + if ( expDiff < 0 ) { + signZ = signC; + expZ = expC; + sig32Z = sig32C - softfloat_shiftRightJam32( sigProd, -expDiff ); + } else if ( ! expDiff ) { + expZ = expProd; + sig32Z = sigProd - sig32C; + if ( ! sig32Z ) goto completeCancellation; + if ( sig32Z & 0x80000000 ) { + signZ = ! signZ; + sig32Z = -sig32Z; + } + } else { + expZ = expProd; + sig32Z = sigProd - softfloat_shiftRightJam32( sig32C, expDiff ); + } + shiftDist = softfloat_countLeadingZeros32( sig32Z ) - 1; + expZ -= shiftDist; + shiftDist -= 16; + if ( shiftDist < 0 ) { + sigZ = + sig32Z>>(-shiftDist) + | ((uint32_t) (sig32Z<<(shiftDist & 31)) != 0); + } else { + sigZ = (uint_fast16_t) sig32Z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t + softfloat_mulAddF32( + uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op ) +{ + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + bool signB; + int_fast16_t expB; + uint_fast32_t sigB; + bool signC; + int_fast16_t expC; + uint_fast32_t sigC; + bool signProd; + uint_fast32_t magBits, uiZ; + struct exp16_sig32 normExpSig; + int_fast16_t expProd; + uint_fast64_t sigProd; + bool signZ; + int_fast16_t expZ; + uint_fast32_t sigZ; + int_fast16_t expDiff; + uint_fast64_t sig64Z, sig64C; + int_fast8_t shiftDist; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + signB = signF32UI( uiB ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + signC = signF32UI( uiC ) ^ (op == softfloat_mulAdd_subC); + expC = expF32UI( uiC ); + sigC = fracF32UI( uiC ); + signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0xFF ) { + if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN_ABC; + magBits = expB | sigB; + goto infProdArg; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN_ABC; + magBits = expA | sigA; + goto infProdArg; + } + if ( expC == 0xFF ) { + if ( sigC ) { + uiZ = 0; + goto propagateNaN_ZC; + } + uiZ = uiC; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) goto zeroProd; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zeroProd; + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expProd = expA + expB - 0x7E; + sigA = (sigA | 0x00800000)<<7; + sigB = (sigB | 0x00800000)<<7; + sigProd = (uint_fast64_t) sigA * sigB; + if ( sigProd < UINT64_C( 0x2000000000000000 ) ) { + --expProd; + sigProd <<= 1; + } + signZ = signProd; + if ( ! expC ) { + if ( ! sigC ) { + expZ = expProd - 1; + sigZ = softfloat_shortShiftRightJam64( sigProd, 31 ); + goto roundPack; + } + normExpSig = softfloat_normSubnormalF32Sig( sigC ); + expC = normExpSig.exp; + sigC = normExpSig.sig; + } + sigC = (sigC | 0x00800000)<<6; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expProd - expC; + if ( signProd == signC ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff <= 0 ) { + expZ = expC; + sigZ = sigC + softfloat_shiftRightJam64( sigProd, 32 - expDiff ); + } else { + expZ = expProd; + sig64Z = + sigProd + + softfloat_shiftRightJam64( + (uint_fast64_t) sigC<<32, expDiff ); + sigZ = softfloat_shortShiftRightJam64( sig64Z, 32 ); + } + if ( sigZ < 0x40000000 ) { + --expZ; + sigZ <<= 1; + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + sig64C = (uint_fast64_t) sigC<<32; + if ( expDiff < 0 ) { + signZ = signC; + expZ = expC; + sig64Z = sig64C - softfloat_shiftRightJam64( sigProd, -expDiff ); + } else if ( ! expDiff ) { + expZ = expProd; + sig64Z = sigProd - sig64C; + if ( ! sig64Z ) goto completeCancellation; + if ( sig64Z & UINT64_C( 0x8000000000000000 ) ) { + signZ = ! signZ; + sig64Z = -sig64Z; + } + } else { + expZ = expProd; + sig64Z = sigProd - softfloat_shiftRightJam64( sig64C, expDiff ); + } + shiftDist = softfloat_countLeadingZeros64( sig64Z ) - 1; + expZ -= shiftDist; + shiftDist -= 32; + if ( shiftDist < 0 ) { + sigZ = softfloat_shortShiftRightJam64( sig64Z, -shiftDist ); + } else { + sigZ = (uint_fast32_t) sig64Z< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +float64_t + softfloat_mulAddF64( + uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op ) +{ + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + bool signB; + int_fast16_t expB; + uint_fast64_t sigB; + bool signC; + int_fast16_t expC; + uint_fast64_t sigC; + bool signZ; + uint_fast64_t magBits, uiZ; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; + struct uint128 sig128Z; + uint_fast64_t sigZ; + int_fast16_t expDiff; + struct uint128 sig128C; + int_fast8_t shiftDist; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC); + expC = expF64UI( uiC ); + sigC = fracF64UI( uiC ); + signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FF ) { + if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC; + magBits = expB | sigB; + goto infProdArg; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN_ABC; + magBits = expA | sigA; + goto infProdArg; + } + if ( expC == 0x7FF ) { + if ( sigC ) { + uiZ = 0; + goto propagateNaN_ZC; + } + uiZ = uiC; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) goto zeroProd; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zeroProd; + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x3FE; + sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10; + sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<10; + sig128Z = softfloat_mul64To128( sigA, sigB ); + if ( sig128Z.v64 < UINT64_C( 0x2000000000000000 ) ) { + --expZ; + sig128Z = + softfloat_add128( + sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 ); + } + if ( ! expC ) { + if ( ! sigC ) { + --expZ; + sigZ = sig128Z.v64<<1 | (sig128Z.v0 != 0); + goto roundPack; + } + normExpSig = softfloat_normSubnormalF64Sig( sigC ); + expC = normExpSig.exp; + sigC = normExpSig.sig; + } + sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<9; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expZ - expC; + if ( expDiff < 0 ) { + expZ = expC; + if ( (signZ == signC) || (expDiff < -1) ) { + sig128Z.v64 = softfloat_shiftRightJam64( sig128Z.v64, -expDiff ); + } else { + sig128Z = + softfloat_shortShiftRightJam128( sig128Z.v64, sig128Z.v0, 1 ); + } + } else if ( expDiff ) { + sig128C = softfloat_shiftRightJam128( sigC, 0, expDiff ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signZ == signC ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff <= 0 ) { + sigZ = (sigC + sig128Z.v64) | (sig128Z.v0 != 0); + } else { + sig128Z = + softfloat_add128( + sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 ); + sigZ = sig128Z.v64 | (sig128Z.v0 != 0); + } + if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { + --expZ; + sigZ <<= 1; + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff < 0 ) { + signZ = signC; + sig128Z = softfloat_sub128( sigC, 0, sig128Z.v64, sig128Z.v0 ); + } else if ( ! expDiff ) { + sig128Z.v64 = sig128Z.v64 - sigC; + if ( ! (sig128Z.v64 | sig128Z.v0) ) goto completeCancellation; + if ( sig128Z.v64 & UINT64_C( 0x8000000000000000 ) ) { + signZ = ! signZ; + sig128Z = softfloat_sub128( 0, 0, sig128Z.v64, sig128Z.v0 ); + } + } else { + sig128Z = + softfloat_sub128( + sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 ); + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( ! sig128Z.v64 ) { + expZ -= 64; + sig128Z.v64 = sig128Z.v0; + sig128Z.v0 = 0; + } + shiftDist = softfloat_countLeadingZeros64( sig128Z.v64 ) - 1; + expZ -= shiftDist; + if ( shiftDist < 0 ) { + sigZ = softfloat_shortShiftRightJam64( sig128Z.v64, -shiftDist ); + } else { + sig128Z = + softfloat_shortShiftLeft128( + sig128Z.v64, sig128Z.v0, shiftDist ); + sigZ = sig128Z.v64; + } + sigZ |= (sig128Z.v0 != 0); + } + roundPack: + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN_ABC: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto propagateNaN_ZC; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infProdArg: + if ( magBits ) { + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + if ( expC != 0x7FF ) goto uiZ; + if ( sigC ) goto propagateNaN_ZC; + if ( signZ == signC ) goto uiZ; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + propagateNaN_ZC: + uiZ = softfloat_propagateNaNF64UI( uiZ, uiC ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zeroProd: + uiZ = uiC; + if ( ! (expC | sigC) && (signZ != signC) ) { + completeCancellation: + uiZ = + packToF64UI( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#else + +float64_t + softfloat_mulAddF64( + uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op ) +{ + bool signA; + int_fast16_t expA; + uint64_t sigA; + bool signB; + int_fast16_t expB; + uint64_t sigB; + bool signC; + int_fast16_t expC; + uint64_t sigC; + bool signZ; + uint64_t magBits, uiZ; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; + uint32_t sig128Z[4]; + uint64_t sigZ; + int_fast16_t shiftDist, expDiff; + uint32_t sig128C[4]; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC); + expC = expF64UI( uiC ); + sigC = fracF64UI( uiC ); + signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( expA == 0x7FF ) { + if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC; + magBits = expB | sigB; + goto infProdArg; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN_ABC; + magBits = expA | sigA; + goto infProdArg; + } + if ( expC == 0x7FF ) { + if ( sigC ) { + uiZ = 0; + goto propagateNaN_ZC; + } + uiZ = uiC; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( ! expA ) { + if ( ! sigA ) goto zeroProd; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zeroProd; + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA + expB - 0x3FE; + sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10; + sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11; + softfloat_mul64To128M( sigA, sigB, sig128Z ); + sigZ = + (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 | sig128Z[indexWord( 4, 2 )]; + shiftDist = 0; + if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) { + --expZ; + shiftDist = -1; + } + if ( ! expC ) { + if ( ! sigC ) { + if ( shiftDist ) sigZ <<= 1; + goto sigZ; + } + normExpSig = softfloat_normSubnormalF64Sig( sigC ); + expC = normExpSig.exp; + sigC = normExpSig.sig; + } + sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<10; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expZ - expC; + if ( expDiff < 0 ) { + expZ = expC; + if ( (signZ == signC) || (expDiff < -1) ) { + shiftDist -= expDiff; + if ( shiftDist) { + sigZ = softfloat_shiftRightJam64( sigZ, shiftDist ); + } + } else { + if ( ! shiftDist ) { + softfloat_shortShiftRight128M( sig128Z, 1, sig128Z ); + } + } + } else { + if ( shiftDist ) softfloat_add128M( sig128Z, sig128Z, sig128Z ); + if ( ! expDiff ) { + sigZ = + (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 + | sig128Z[indexWord( 4, 2 )]; + } else { + sig128C[indexWord( 4, 3 )] = sigC>>32; + sig128C[indexWord( 4, 2 )] = sigC; + sig128C[indexWord( 4, 1 )] = 0; + sig128C[indexWord( 4, 0 )] = 0; + softfloat_shiftRightJam128M( sig128C, expDiff, sig128C ); + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( signZ == signC ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff <= 0 ) { + sigZ += sigC; + } else { + softfloat_add128M( sig128Z, sig128C, sig128Z ); + sigZ = + (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 + | sig128Z[indexWord( 4, 2 )]; + } + if ( sigZ & UINT64_C( 0x8000000000000000 ) ) { + ++expZ; + sigZ = softfloat_shortShiftRightJam64( sigZ, 1 ); + } + } else { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expDiff < 0 ) { + signZ = signC; + if ( expDiff < -1 ) { + sigZ = sigC - sigZ; + if ( + sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] + ) { + sigZ = (sigZ - 1) | 1; + } + if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) { + --expZ; + sigZ <<= 1; + } + goto roundPack; + } else { + sig128C[indexWord( 4, 3 )] = sigC>>32; + sig128C[indexWord( 4, 2 )] = sigC; + sig128C[indexWord( 4, 1 )] = 0; + sig128C[indexWord( 4, 0 )] = 0; + softfloat_sub128M( sig128C, sig128Z, sig128Z ); + } + } else if ( ! expDiff ) { + sigZ -= sigC; + if ( + ! sigZ && ! sig128Z[indexWord( 4, 1 )] + && ! sig128Z[indexWord( 4, 0 )] + ) { + goto completeCancellation; + } + sig128Z[indexWord( 4, 3 )] = sigZ>>32; + sig128Z[indexWord( 4, 2 )] = sigZ; + if ( sigZ & UINT64_C( 0x8000000000000000 ) ) { + signZ = ! signZ; + softfloat_negX128M( sig128Z ); + } + } else { + softfloat_sub128M( sig128Z, sig128C, sig128Z ); + if ( 1 < expDiff ) { + sigZ = + (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 + | sig128Z[indexWord( 4, 2 )]; + if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) { + --expZ; + sigZ <<= 1; + } + goto sigZ; + } + } + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + shiftDist = 0; + sigZ = + (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 + | sig128Z[indexWord( 4, 2 )]; + if ( ! sigZ ) { + shiftDist = 64; + sigZ = + (uint64_t) sig128Z[indexWord( 4, 1 )]<<32 + | sig128Z[indexWord( 4, 0 )]; + } + shiftDist += softfloat_countLeadingZeros64( sigZ ) - 1; + if ( shiftDist ) { + expZ -= shiftDist; + softfloat_shiftLeft128M( sig128Z, shiftDist, sig128Z ); + sigZ = + (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 + | sig128Z[indexWord( 4, 2 )]; + } + } + sigZ: + if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1; + roundPack: + return softfloat_roundPackToF64( signZ, expZ - 1, sigZ ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN_ABC: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto propagateNaN_ZC; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + infProdArg: + if ( magBits ) { + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + if ( expC != 0x7FF ) goto uiZ; + if ( sigC ) goto propagateNaN_ZC; + if ( signZ == signC ) goto uiZ; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + propagateNaN_ZC: + uiZ = softfloat_propagateNaNF64UI( uiZ, uiC ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + zeroProd: + uiZ = uiC; + if ( ! (expC | sigC) && (signZ != signC) ) { + completeCancellation: + uiZ = + packToF64UI( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_negXM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_negXM.c new file mode 100644 index 000000000..ec8c92886 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_negXM.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_negXM + +void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr ) +{ + unsigned int index, lastIndex; + uint_fast8_t carry; + uint32_t word; + + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + carry = 1; + for (;;) { + word = ~zPtr[index] + carry; + zPtr[index] = word; + if ( index == lastIndex ) break; + index += wordIncr; + if ( word ) carry = 0; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normExtF80SigM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normExtF80SigM.c new file mode 100644 index 000000000..acc54dc63 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normExtF80SigM.c @@ -0,0 +1,52 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" + +int softfloat_normExtF80SigM( uint64_t *sigPtr ) +{ + uint64_t sig; + int_fast8_t shiftDist; + + sig = *sigPtr; + shiftDist = softfloat_countLeadingZeros64( sig ); + *sigPtr = sig< +#include +#include "platform.h" +#include "internals.h" + +void + softfloat_normRoundPackMToExtF80M( + bool sign, + int32_t exp, + uint32_t *extSigPtr, + uint_fast8_t roundingPrecision, + struct extFloat80M *zSPtr + ) +{ + int_fast16_t shiftDist; + uint32_t wordSig; + + shiftDist = 0; + wordSig = extSigPtr[indexWord( 3, 2 )]; + if ( ! wordSig ) { + shiftDist = 32; + wordSig = extSigPtr[indexWord( 3, 1 )]; + if ( ! wordSig ) { + shiftDist = 64; + wordSig = extSigPtr[indexWord( 3, 0 )]; + if ( ! wordSig ) { + zSPtr->signExp = packToExtF80UI64( sign, 0 ); + zSPtr->signif = 0; + return; + } + } + } + shiftDist += softfloat_countLeadingZeros32( wordSig ); + if ( shiftDist ) { + exp -= shiftDist; + softfloat_shiftLeft96M( extSigPtr, shiftDist, extSigPtr ); + } + softfloat_roundPackMToExtF80M( + sign, exp, extSigPtr, roundingPrecision, zSPtr ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackMToF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackMToF128M.c new file mode 100644 index 000000000..309455998 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackMToF128M.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" + +void + softfloat_normRoundPackMToF128M( + bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr ) +{ + const uint32_t *ptr; + int_fast16_t shiftDist; + uint32_t wordSig; + + ptr = extSigPtr + indexWordHi( 5 ); + shiftDist = 0; + for (;;) { + wordSig = *ptr; + if ( wordSig ) break; + shiftDist += 32; + if ( 160 <= shiftDist ) { + zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, 0, 0 ); + zWPtr[indexWord( 4, 2 )] = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + return; + } + ptr -= wordIncr; + } + shiftDist += softfloat_countLeadingZeros32( wordSig ) - 15; + if ( shiftDist ) { + exp -= shiftDist; + softfloat_shiftLeft160M( extSigPtr, shiftDist, extSigPtr ); + } + softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToExtF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToExtF80.c new file mode 100644 index 000000000..76e791d91 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToExtF80.c @@ -0,0 +1,71 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" + +extFloat80_t + softfloat_normRoundPackToExtF80( + bool sign, + int_fast32_t exp, + uint_fast64_t sig, + uint_fast64_t sigExtra, + uint_fast8_t roundingPrecision + ) +{ + int_fast8_t shiftDist; + struct uint128 sig128; + + if ( ! sig ) { + exp -= 64; + sig = sigExtra; + sigExtra = 0; + } + shiftDist = softfloat_countLeadingZeros64( sig ); + exp -= shiftDist; + if ( shiftDist ) { + sig128 = softfloat_shortShiftLeft128( sig, sigExtra, shiftDist ); + sig = sig128.v64; + sigExtra = sig128.v0; + } + return + softfloat_roundPackToExtF80( + sign, exp, sig, sigExtra, roundingPrecision ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF128.c new file mode 100644 index 000000000..67f5b4349 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF128.c @@ -0,0 +1,81 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" + +float128_t + softfloat_normRoundPackToF128( + bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 ) +{ + int_fast8_t shiftDist; + struct uint128 sig128; + union ui128_f128 uZ; + uint_fast64_t sigExtra; + struct uint128_extra sig128Extra; + + if ( ! sig64 ) { + exp -= 64; + sig64 = sig0; + sig0 = 0; + } + shiftDist = softfloat_countLeadingZeros64( sig64 ) - 15; + exp -= shiftDist; + if ( 0 <= shiftDist ) { + if ( shiftDist ) { + sig128 = softfloat_shortShiftLeft128( sig64, sig0, shiftDist ); + sig64 = sig128.v64; + sig0 = sig128.v0; + } + if ( (uint32_t) exp < 0x7FFD ) { + uZ.ui.v64 = packToF128UI64( sign, sig64 | sig0 ? exp : 0, sig64 ); + uZ.ui.v0 = sig0; + return uZ.f; + } + sigExtra = 0; + } else { + sig128Extra = + softfloat_shortShiftRightJam128Extra( sig64, sig0, 0, -shiftDist ); + sig64 = sig128Extra.v.v64; + sig0 = sig128Extra.v.v0; + sigExtra = sig128Extra.extra; + } + return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF16.c new file mode 100644 index 000000000..1d184d58b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normRoundPackToF16.c @@ -0,0 +1,58 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" + +float16_t + softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig ) +{ + int_fast8_t shiftDist; + union ui16_f16 uZ; + + shiftDist = softfloat_countLeadingZeros16( sig ) - 1; + exp -= shiftDist; + if ( (4 <= shiftDist) && ((unsigned int) exp < 0x1D) ) { + uZ.ui = packToF16UI( sign, sig ? exp : 0, sig<<(shiftDist - 4) ); + return uZ.f; + } else { + return softfloat_roundPackToF16( sign, exp, sig< +#include +#include "platform.h" +#include "internals.h" + +float32_t + softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig ) +{ + int_fast8_t shiftDist; + union ui32_f32 uZ; + + shiftDist = softfloat_countLeadingZeros32( sig ) - 1; + exp -= shiftDist; + if ( (7 <= shiftDist) && ((unsigned int) exp < 0xFD) ) { + uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<(shiftDist - 7) ); + return uZ.f; + } else { + return softfloat_roundPackToF32( sign, exp, sig< +#include +#include "platform.h" +#include "internals.h" + +float64_t + softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig ) +{ + int_fast8_t shiftDist; + union ui64_f64 uZ; + + shiftDist = softfloat_countLeadingZeros64( sig ) - 1; + exp -= shiftDist; + if ( (10 <= shiftDist) && ((unsigned int) exp < 0x7FD) ) { + uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<(shiftDist - 10) ); + return uZ.f; + } else { + return softfloat_roundPackToF64( sign, exp, sig< +#include "platform.h" +#include "internals.h" + +struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t sig ) +{ + int_fast8_t shiftDist; + struct exp32_sig64 z; + + shiftDist = softfloat_countLeadingZeros64( sig ); + z.exp = -shiftDist; + z.sig = sig< +#include "platform.h" +#include "internals.h" + +struct exp32_sig128 + softfloat_normSubnormalF128Sig( uint_fast64_t sig64, uint_fast64_t sig0 ) +{ + int_fast8_t shiftDist; + struct exp32_sig128 z; + + if ( ! sig64 ) { + shiftDist = softfloat_countLeadingZeros64( sig0 ) - 15; + z.exp = -63 - shiftDist; + if ( shiftDist < 0 ) { + z.sig.v64 = sig0>>-shiftDist; + z.sig.v0 = sig0<<(shiftDist & 63); + } else { + z.sig.v64 = sig0< +#include "platform.h" +#include "internals.h" + +int softfloat_normSubnormalF128SigM( uint32_t *sigPtr ) +{ + const uint32_t *ptr; + int_fast16_t shiftDist; + uint32_t wordSig; + + ptr = sigPtr + indexWordHi( 4 ); + shiftDist = 0; + for (;;) { + wordSig = *ptr; + if ( wordSig ) break; + shiftDist += 32; + if ( 128 <= shiftDist ) return 1; + ptr -= wordIncr; + } + shiftDist += softfloat_countLeadingZeros32( wordSig ) - 15; + if ( shiftDist ) softfloat_shiftLeft128M( sigPtr, shiftDist, sigPtr ); + return 1 - shiftDist; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF16Sig.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF16Sig.c new file mode 100644 index 000000000..bb92adfea --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_normSubnormalF16Sig.c @@ -0,0 +1,52 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" + +struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t sig ) +{ + int_fast8_t shiftDist; + struct exp8_sig16 z; + + shiftDist = softfloat_countLeadingZeros16( sig ) - 5; + z.exp = 1 - shiftDist; + z.sig = sig< +#include "platform.h" +#include "internals.h" + +struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig ) +{ + int_fast8_t shiftDist; + struct exp16_sig32 z; + + shiftDist = softfloat_countLeadingZeros32( sig ) - 8; + z.exp = 1 - shiftDist; + z.sig = sig< +#include "platform.h" +#include "internals.h" + +struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t sig ) +{ + int_fast8_t shiftDist; + struct exp16_sig64 z; + + shiftDist = softfloat_countLeadingZeros64( sig ) - 11; + z.exp = 1 - shiftDist; + z.sig = sig< +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_remStepMBy32 + +void + softfloat_remStepMBy32( + uint_fast8_t size_words, + const uint32_t *remPtr, + uint_fast8_t dist, + const uint32_t *bPtr, + uint32_t q, + uint32_t *zPtr + ) +{ + unsigned int index, lastIndex; + uint64_t dwordProd; + uint32_t wordRem, wordShiftedRem, wordProd; + uint_fast8_t uNegDist, borrow; + + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + dwordProd = (uint64_t) bPtr[index] * q; + wordRem = remPtr[index]; + wordShiftedRem = wordRem<>(uNegDist & 31); + index += wordIncr; + dwordProd = (uint64_t) bPtr[index] * q + (dwordProd>>32); + wordRem = remPtr[index]; + wordShiftedRem |= wordRem< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t + softfloat_roundMToI64( + bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint64_t sig; + uint32_t sigExtra; + union { uint64_t ui; int64_t i; } uZ; + int64_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = + (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32 + | extSigPtr[indexWord( 3, 1 )]; + sigExtra = extSigPtr[indexWordLo( 3 )]; + if ( + (roundingMode == softfloat_round_near_maxMag) + || (roundingMode == softfloat_round_near_even) + ) { + if ( 0x80000000 <= sigExtra ) goto increment; + } else { + if ( + sigExtra + && (sign + ? (roundingMode == softfloat_round_min) +#ifdef SOFTFLOAT_ROUND_ODD + || (roundingMode == softfloat_round_odd) +#endif + : (roundingMode == softfloat_round_max)) + ) { + increment: + ++sig; + if ( !sig ) goto invalid; + if ( + (sigExtra == 0x80000000) + && (roundingMode == softfloat_round_near_even) + ) { + sig &= ~(uint_fast64_t) 1; + } + } + } + uZ.ui = sign ? -sig : sig; + z = uZ.i; + if ( z && ((z < 0) ^ sign) ) goto invalid; + if ( sigExtra ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) z |= 1; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return sign ? i64_fromNegOverflow : i64_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundMToUI64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundMToUI64.c new file mode 100644 index 000000000..196f53735 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundMToUI64.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t + softfloat_roundMToUI64( + bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint64_t sig; + uint32_t sigExtra; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = + (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32 + | extSigPtr[indexWord( 3, 1 )]; + sigExtra = extSigPtr[indexWordLo( 3 )]; + if ( + (roundingMode == softfloat_round_near_maxMag) + || (roundingMode == softfloat_round_near_even) + ) { + if ( 0x80000000 <= sigExtra ) goto increment; + } else { + if ( sign ) { + if ( !(sig | sigExtra) ) return 0; + if ( roundingMode == softfloat_round_min ) goto invalid; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) goto invalid; +#endif + } else { + if ( (roundingMode == softfloat_round_max) && sigExtra ) { + increment: + ++sig; + if ( !sig ) goto invalid; + if ( + (sigExtra == 0x80000000) + && (roundingMode == softfloat_round_near_even) + ) { + sig &= ~(uint_fast64_t) 1; + } + } + } + } + if ( sign && sig ) goto invalid; + if ( sigExtra ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) sig |= 1; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return sig; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToExtF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToExtF80M.c new file mode 100644 index 000000000..08620159f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToExtF80M.c @@ -0,0 +1,256 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +void + softfloat_roundPackMToExtF80M( + bool sign, + int32_t exp, + uint32_t *extSigPtr, + uint_fast8_t roundingPrecision, + struct extFloat80M *zSPtr + ) +{ + uint_fast8_t roundingMode; + bool roundNearEven; + uint64_t sig, roundIncrement, roundMask, roundBits; + bool isTiny; + uint32_t sigExtra; + bool doIncrement; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundingMode = softfloat_roundingMode; + roundNearEven = (roundingMode == softfloat_round_near_even); + sig = + (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32 + | extSigPtr[indexWord( 3, 1 )]; + if ( roundingPrecision == 80 ) goto precision80; + if ( roundingPrecision == 64 ) { + roundIncrement = UINT64_C( 0x0000000000000400 ); + roundMask = UINT64_C( 0x00000000000007FF ); + } else if ( roundingPrecision == 32 ) { + roundIncrement = UINT64_C( 0x0000008000000000 ); + roundMask = UINT64_C( 0x000000FFFFFFFFFF ); + } else { + goto precision80; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( extSigPtr[indexWordLo( 3 )] ) sig |= 1; + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + roundIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ? roundMask + : 0; + } + roundBits = sig & roundMask; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x7FFD <= (uint32_t) (exp - 1) ) { + if ( exp <= 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess + == softfloat_tininess_beforeRounding) + || (exp < 0) + || (sig <= (uint64_t) (sig + roundIncrement)); + sig = softfloat_shiftRightJam64( sig, 1 - exp ); + roundBits = sig & roundMask; + if ( roundBits ) { + if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow ); + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= roundMask + 1; + } +#endif + } + sig += roundIncrement; + exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0); + roundIncrement = roundMask + 1; + if ( roundNearEven && (roundBits<<1 == roundIncrement) ) { + roundMask |= roundIncrement; + } + sig &= ~roundMask; + goto packReturn; + } + if ( + (0x7FFE < exp) + || ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig)) + ) { + goto overflow; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( roundBits ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig = (sig & ~roundMask) | (roundMask + 1); + goto packReturn; + } +#endif + } + sig += roundIncrement; + if ( sig < roundIncrement ) { + ++exp; + sig = UINT64_C( 0x8000000000000000 ); + } + roundIncrement = roundMask + 1; + if ( roundNearEven && (roundBits<<1 == roundIncrement) ) { + roundMask |= roundIncrement; + } + sig &= ~roundMask; + goto packReturn; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + precision80: + sigExtra = extSigPtr[indexWordLo( 3 )]; + doIncrement = (0x80000000 <= sigExtra); + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x7FFD <= (uint32_t) (exp - 1) ) { + if ( exp <= 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess + == softfloat_tininess_beforeRounding) + || (exp < 0) + || ! doIncrement + || (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF )); + softfloat_shiftRightJam96M( extSigPtr, 1 - exp, extSigPtr ); + exp = 0; + sig = + (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32 + | extSigPtr[indexWord( 3, 1 )]; + sigExtra = extSigPtr[indexWordLo( 3 )]; + if ( sigExtra ) { + if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow ); + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= 1; + goto packReturn; + } +#endif + } + doIncrement = (0x80000000 <= sigExtra); + if ( + ! roundNearEven + && (roundingMode != softfloat_round_near_maxMag) + ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + if ( doIncrement ) { + ++sig; + sig &= ~(uint64_t) (! (sigExtra & 0x7FFFFFFF) & roundNearEven); + exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0); + } + goto packReturn; + } + if ( + (0x7FFE < exp) + || ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF )) + && doIncrement) + ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + roundMask = 0; + overflow: + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + if ( + roundNearEven + || (roundingMode == softfloat_round_near_maxMag) + || (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ) { + exp = 0x7FFF; + sig = UINT64_C( 0x8000000000000000 ); + } else { + exp = 0x7FFE; + sig = ~roundMask; + } + goto packReturn; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( sigExtra ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= 1; + goto packReturn; + } +#endif + } + if ( doIncrement ) { + ++sig; + if ( ! sig ) { + ++exp; + sig = UINT64_C( 0x8000000000000000 ); + } else { + sig &= ~(uint64_t) (! (sigExtra & 0x7FFFFFFF) & roundNearEven); + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + packReturn: + zSPtr->signExp = packToExtF80UI64( sign, exp ); + zSPtr->signif = sig; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToF128M.c new file mode 100644 index 000000000..22591b835 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackMToF128M.c @@ -0,0 +1,178 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +void + softfloat_roundPackMToF128M( + bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr ) +{ + uint_fast8_t roundingMode; + bool roundNearEven; + uint32_t sigExtra; + bool doIncrement, isTiny; + static const uint32_t maxSig[4] = + INIT_UINTM4( 0x0001FFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF ); + uint32_t ui, uj; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundingMode = softfloat_roundingMode; + roundNearEven = (roundingMode == softfloat_round_near_even); + sigExtra = extSigPtr[indexWordLo( 5 )]; + doIncrement = (0x80000000 <= sigExtra); + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x7FFD <= (uint32_t) exp ) { + if ( exp < 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess + == softfloat_tininess_beforeRounding) + || (exp < -1) + || ! doIncrement + || (softfloat_compare128M( + extSigPtr + indexMultiwordHi( 5, 4 ), maxSig ) + < 0); + softfloat_shiftRightJam160M( extSigPtr, -exp, extSigPtr ); + exp = 0; + sigExtra = extSigPtr[indexWordLo( 5 )]; + if ( isTiny && sigExtra ) { + softfloat_raiseFlags( softfloat_flag_underflow ); + } + doIncrement = (0x80000000 <= sigExtra); + if ( + ! roundNearEven + && (roundingMode != softfloat_round_near_maxMag) + ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + } else if ( + (0x7FFD < exp) + || ((exp == 0x7FFD) && doIncrement + && (softfloat_compare128M( + extSigPtr + indexMultiwordHi( 5, 4 ), maxSig ) + == 0)) + ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + if ( + roundNearEven + || (roundingMode == softfloat_round_near_maxMag) + || (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ) { + ui = packToF128UI96( sign, 0x7FFF, 0 ); + uj = 0; + } else { + ui = packToF128UI96( sign, 0x7FFE, 0x0000FFFF ); + uj = 0xFFFFFFFF; + } + zWPtr[indexWordHi( 4 )] = ui; + zWPtr[indexWord( 4, 2 )] = uj; + zWPtr[indexWord( 4, 1 )] = uj; + zWPtr[indexWord( 4, 0 )] = uj; + return; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + uj = extSigPtr[indexWord( 5, 1 )]; + if ( sigExtra ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + uj |= 1; + goto noIncrementPackReturn; + } +#endif + } + if ( doIncrement ) { + ++uj; + if ( uj ) { + if ( ! (sigExtra & 0x7FFFFFFF) && roundNearEven ) uj &= ~1; + zWPtr[indexWord( 4, 2 )] = extSigPtr[indexWord( 5, 3 )]; + zWPtr[indexWord( 4, 1 )] = extSigPtr[indexWord( 5, 2 )]; + zWPtr[indexWord( 4, 0 )] = uj; + ui = extSigPtr[indexWordHi( 5 )]; + } else { + zWPtr[indexWord( 4, 0 )] = uj; + ui = extSigPtr[indexWord( 5, 2 )] + 1; + zWPtr[indexWord( 4, 1 )] = ui; + uj = extSigPtr[indexWord( 5, 3 )]; + if ( ui ) { + zWPtr[indexWord( 4, 2 )] = uj; + ui = extSigPtr[indexWordHi( 5 )]; + } else { + ++uj; + zWPtr[indexWord( 4, 2 )] = uj; + ui = extSigPtr[indexWordHi( 5 )]; + if ( ! uj ) ++ui; + } + } + } else { + noIncrementPackReturn: + zWPtr[indexWord( 4, 0 )] = uj; + ui = extSigPtr[indexWord( 5, 2 )]; + zWPtr[indexWord( 4, 1 )] = ui; + uj |= ui; + ui = extSigPtr[indexWord( 5, 3 )]; + zWPtr[indexWord( 4, 2 )] = ui; + uj |= ui; + ui = extSigPtr[indexWordHi( 5 )]; + uj |= ui; + if ( ! uj ) exp = 0; + } + zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp, ui ); + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToExtF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToExtF80.c new file mode 100644 index 000000000..0cc7af985 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToExtF80.c @@ -0,0 +1,256 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +extFloat80_t + softfloat_roundPackToExtF80( + bool sign, + int_fast32_t exp, + uint_fast64_t sig, + uint_fast64_t sigExtra, + uint_fast8_t roundingPrecision + ) +{ + uint_fast8_t roundingMode; + bool roundNearEven; + uint_fast64_t roundIncrement, roundMask, roundBits; + bool isTiny, doIncrement; + struct uint64_extra sig64Extra; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundingMode = softfloat_roundingMode; + roundNearEven = (roundingMode == softfloat_round_near_even); + if ( roundingPrecision == 80 ) goto precision80; + if ( roundingPrecision == 64 ) { + roundIncrement = UINT64_C( 0x0000000000000400 ); + roundMask = UINT64_C( 0x00000000000007FF ); + } else if ( roundingPrecision == 32 ) { + roundIncrement = UINT64_C( 0x0000008000000000 ); + roundMask = UINT64_C( 0x000000FFFFFFFFFF ); + } else { + goto precision80; + } + sig |= (sigExtra != 0); + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + roundIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ? roundMask + : 0; + } + roundBits = sig & roundMask; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x7FFD <= (uint32_t) (exp - 1) ) { + if ( exp <= 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess + == softfloat_tininess_beforeRounding) + || (exp < 0) + || (sig <= (uint64_t) (sig + roundIncrement)); + sig = softfloat_shiftRightJam64( sig, 1 - exp ); + roundBits = sig & roundMask; + if ( roundBits ) { + if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow ); + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= roundMask + 1; + } +#endif + } + sig += roundIncrement; + exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0); + roundIncrement = roundMask + 1; + if ( roundNearEven && (roundBits<<1 == roundIncrement) ) { + roundMask |= roundIncrement; + } + sig &= ~roundMask; + goto packReturn; + } + if ( + (0x7FFE < exp) + || ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig)) + ) { + goto overflow; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( roundBits ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig = (sig & ~roundMask) | (roundMask + 1); + goto packReturn; + } +#endif + } + sig = (uint64_t) (sig + roundIncrement); + if ( sig < roundIncrement ) { + ++exp; + sig = UINT64_C( 0x8000000000000000 ); + } + roundIncrement = roundMask + 1; + if ( roundNearEven && (roundBits<<1 == roundIncrement) ) { + roundMask |= roundIncrement; + } + sig &= ~roundMask; + goto packReturn; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + precision80: + doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra); + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x7FFD <= (uint32_t) (exp - 1) ) { + if ( exp <= 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess + == softfloat_tininess_beforeRounding) + || (exp < 0) + || ! doIncrement + || (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF )); + sig64Extra = + softfloat_shiftRightJam64Extra( sig, sigExtra, 1 - exp ); + exp = 0; + sig = sig64Extra.v; + sigExtra = sig64Extra.extra; + if ( sigExtra ) { + if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow ); + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= 1; + goto packReturn; + } +#endif + } + doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra); + if ( + ! roundNearEven + && (roundingMode != softfloat_round_near_maxMag) + ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + if ( doIncrement ) { + ++sig; + sig &= + ~(uint_fast64_t) + (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + & roundNearEven); + exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0); + } + goto packReturn; + } + if ( + (0x7FFE < exp) + || ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF )) + && doIncrement) + ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + roundMask = 0; + overflow: + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + if ( + roundNearEven + || (roundingMode == softfloat_round_near_maxMag) + || (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ) { + exp = 0x7FFF; + sig = UINT64_C( 0x8000000000000000 ); + } else { + exp = 0x7FFE; + sig = ~roundMask; + } + goto packReturn; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( sigExtra ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= 1; + goto packReturn; + } +#endif + } + if ( doIncrement ) { + ++sig; + if ( ! sig ) { + ++exp; + sig = UINT64_C( 0x8000000000000000 ); + } else { + sig &= + ~(uint_fast64_t) + (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + & roundNearEven); + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + packReturn: + uZ.s.signExp = packToExtF80UI64( sign, exp ); + uZ.s.signif = sig; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF128.c new file mode 100644 index 000000000..41584316a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF128.c @@ -0,0 +1,171 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t + softfloat_roundPackToF128( + bool sign, + int_fast32_t exp, + uint_fast64_t sig64, + uint_fast64_t sig0, + uint_fast64_t sigExtra + ) +{ + uint_fast8_t roundingMode; + bool roundNearEven, doIncrement, isTiny; + struct uint128_extra sig128Extra; + uint_fast64_t uiZ64, uiZ0; + struct uint128 sig128; + union ui128_f128 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundingMode = softfloat_roundingMode; + roundNearEven = (roundingMode == softfloat_round_near_even); + doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra); + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x7FFD <= (uint32_t) exp ) { + if ( exp < 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess + == softfloat_tininess_beforeRounding) + || (exp < -1) + || ! doIncrement + || softfloat_lt128( + sig64, + sig0, + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0xFFFFFFFFFFFFFFFF ) + ); + sig128Extra = + softfloat_shiftRightJam128Extra( sig64, sig0, sigExtra, -exp ); + sig64 = sig128Extra.v.v64; + sig0 = sig128Extra.v.v0; + sigExtra = sig128Extra.extra; + exp = 0; + if ( isTiny && sigExtra ) { + softfloat_raiseFlags( softfloat_flag_underflow ); + } + doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra); + if ( + ! roundNearEven + && (roundingMode != softfloat_round_near_maxMag) + ) { + doIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + && sigExtra; + } + } else if ( + (0x7FFD < exp) + || ((exp == 0x7FFD) + && softfloat_eq128( + sig64, + sig0, + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0xFFFFFFFFFFFFFFFF ) + ) + && doIncrement) + ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + if ( + roundNearEven + || (roundingMode == softfloat_round_near_maxMag) + || (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ) { + uiZ64 = packToF128UI64( sign, 0x7FFF, 0 ); + uiZ0 = 0; + } else { + uiZ64 = + packToF128UI64( + sign, 0x7FFE, UINT64_C( 0x0000FFFFFFFFFFFF ) ); + uiZ0 = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + } + goto uiZ; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( sigExtra ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig0 |= 1; + goto packReturn; + } +#endif + } + if ( doIncrement ) { + sig128 = softfloat_add128( sig64, sig0, 0, 1 ); + sig64 = sig128.v64; + sig0 = + sig128.v0 + & ~(uint64_t) + (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF )) + & roundNearEven); + } else { + if ( ! (sig64 | sig0) ) exp = 0; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + packReturn: + uiZ64 = packToF128UI64( sign, exp, sig64 ); + uiZ0 = sig0; + uiZ: + uZ.ui.v64 = uiZ64; + uZ.ui.v0 = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF16.c new file mode 100644 index 000000000..2dde55bb4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF16.c @@ -0,0 +1,113 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t + softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig ) +{ + uint_fast8_t roundingMode; + bool roundNearEven; + uint_fast8_t roundIncrement, roundBits; + bool isTiny; + uint_fast16_t uiZ; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundingMode = softfloat_roundingMode; + roundNearEven = (roundingMode == softfloat_round_near_even); + roundIncrement = 0x8; + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + roundIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ? 0xF + : 0; + } + roundBits = sig & 0xF; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x1D <= (unsigned int) exp ) { + if ( exp < 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess == softfloat_tininess_beforeRounding) + || (exp < -1) || (sig + roundIncrement < 0x8000); + sig = softfloat_shiftRightJam32( sig, -exp ); + exp = 0; + roundBits = sig & 0xF; + if ( isTiny && roundBits ) { + softfloat_raiseFlags( softfloat_flag_underflow ); + } + } else if ( (0x1D < exp) || (0x8000 <= sig + roundIncrement) ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + uiZ = packToF16UI( sign, 0x1F, 0 ) - ! roundIncrement; + goto uiZ; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = (sig + roundIncrement)>>4; + if ( roundBits ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= 1; + goto packReturn; + } +#endif + } + sig &= ~(uint_fast16_t) (! (roundBits ^ 8) & roundNearEven); + if ( ! sig ) exp = 0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + packReturn: + uiZ = packToF16UI( sign, exp, sig ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF32.c new file mode 100644 index 000000000..a69b8d4d7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF32.c @@ -0,0 +1,113 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t + softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig ) +{ + uint_fast8_t roundingMode; + bool roundNearEven; + uint_fast8_t roundIncrement, roundBits; + bool isTiny; + uint_fast32_t uiZ; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundingMode = softfloat_roundingMode; + roundNearEven = (roundingMode == softfloat_round_near_even); + roundIncrement = 0x40; + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + roundIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ? 0x7F + : 0; + } + roundBits = sig & 0x7F; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0xFD <= (unsigned int) exp ) { + if ( exp < 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess == softfloat_tininess_beforeRounding) + || (exp < -1) || (sig + roundIncrement < 0x80000000); + sig = softfloat_shiftRightJam32( sig, -exp ); + exp = 0; + roundBits = sig & 0x7F; + if ( isTiny && roundBits ) { + softfloat_raiseFlags( softfloat_flag_underflow ); + } + } else if ( (0xFD < exp) || (0x80000000 <= sig + roundIncrement) ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement; + goto uiZ; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = (sig + roundIncrement)>>7; + if ( roundBits ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= 1; + goto packReturn; + } +#endif + } + sig &= ~(uint_fast32_t) (! (roundBits ^ 0x40) & roundNearEven); + if ( ! sig ) exp = 0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + packReturn: + uiZ = packToF32UI( sign, exp, sig ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF64.c new file mode 100644 index 000000000..f7f3abff5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundPackToF64.c @@ -0,0 +1,117 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t + softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig ) +{ + uint_fast8_t roundingMode; + bool roundNearEven; + uint_fast16_t roundIncrement, roundBits; + bool isTiny; + uint_fast64_t uiZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundingMode = softfloat_roundingMode; + roundNearEven = (roundingMode == softfloat_round_near_even); + roundIncrement = 0x200; + if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) { + roundIncrement = + (roundingMode + == (sign ? softfloat_round_min : softfloat_round_max)) + ? 0x3FF + : 0; + } + roundBits = sig & 0x3FF; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( 0x7FD <= (uint16_t) exp ) { + if ( exp < 0 ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + isTiny = + (softfloat_detectTininess == softfloat_tininess_beforeRounding) + || (exp < -1) + || (sig + roundIncrement < UINT64_C( 0x8000000000000000 )); + sig = softfloat_shiftRightJam64( sig, -exp ); + exp = 0; + roundBits = sig & 0x3FF; + if ( isTiny && roundBits ) { + softfloat_raiseFlags( softfloat_flag_underflow ); + } + } else if ( + (0x7FD < exp) + || (UINT64_C( 0x8000000000000000 ) <= sig + roundIncrement) + ) { + /*---------------------------------------------------------------- + *----------------------------------------------------------------*/ + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement; + goto uiZ; + } + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + sig = (sig + roundIncrement)>>10; + if ( roundBits ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) { + sig |= 1; + goto packReturn; + } +#endif + } + sig &= ~(uint_fast64_t) (! (roundBits ^ 0x200) & roundNearEven); + if ( ! sig ) exp = 0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + packReturn: + uiZ = packToF64UI( sign, exp, sig ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI32.c new file mode 100644 index 000000000..a3e727dc7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI32.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast32_t + softfloat_roundToI32( + bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast16_t roundIncrement, roundBits; + uint_fast32_t sig32; + union { uint32_t ui; int32_t i; } uZ; + int_fast32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundIncrement = 0x800; + if ( + (roundingMode != softfloat_round_near_maxMag) + && (roundingMode != softfloat_round_near_even) + ) { + roundIncrement = 0; + if ( + sign + ? (roundingMode == softfloat_round_min) +#ifdef SOFTFLOAT_ROUND_ODD + || (roundingMode == softfloat_round_odd) +#endif + : (roundingMode == softfloat_round_max) + ) { + roundIncrement = 0xFFF; + } + } + roundBits = sig & 0xFFF; + sig += roundIncrement; + if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid; + sig32 = sig>>12; + if ( + (roundBits == 0x800) && (roundingMode == softfloat_round_near_even) + ) { + sig32 &= ~(uint_fast32_t) 1; + } + uZ.ui = sign ? -sig32 : sig32; + z = uZ.i; + if ( z && ((z < 0) ^ sign) ) goto invalid; + if ( roundBits ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) z |= 1; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return sign ? i32_fromNegOverflow : i32_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI64.c new file mode 100644 index 000000000..773c82cfc --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToI64.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +int_fast64_t + softfloat_roundToI64( + bool sign, + uint_fast64_t sig, + uint_fast64_t sigExtra, + uint_fast8_t roundingMode, + bool exact + ) +{ + union { uint64_t ui; int64_t i; } uZ; + int_fast64_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( + (roundingMode == softfloat_round_near_maxMag) + || (roundingMode == softfloat_round_near_even) + ) { + if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment; + } else { + if ( + sigExtra + && (sign + ? (roundingMode == softfloat_round_min) +#ifdef SOFTFLOAT_ROUND_ODD + || (roundingMode == softfloat_round_odd) +#endif + : (roundingMode == softfloat_round_max)) + ) { + increment: + ++sig; + if ( !sig ) goto invalid; + if ( + (sigExtra == UINT64_C( 0x8000000000000000 )) + && (roundingMode == softfloat_round_near_even) + ) { + sig &= ~(uint_fast64_t) 1; + } + } + } + uZ.ui = sign ? -sig : sig; + z = uZ.i; + if ( z && ((z < 0) ^ sign) ) goto invalid; + if ( sigExtra ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) z |= 1; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return sign ? i64_fromNegOverflow : i64_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI32.c new file mode 100644 index 000000000..059e231e2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI32.c @@ -0,0 +1,93 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast32_t + softfloat_roundToUI32( + bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast16_t roundIncrement, roundBits; + uint_fast32_t z; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + roundIncrement = 0x800; + if ( + (roundingMode != softfloat_round_near_maxMag) + && (roundingMode != softfloat_round_near_even) + ) { + roundIncrement = 0; + if ( sign ) { + if ( !sig ) return 0; + if ( roundingMode == softfloat_round_min ) goto invalid; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) goto invalid; +#endif + } else { + if ( roundingMode == softfloat_round_max ) roundIncrement = 0xFFF; + } + } + roundBits = sig & 0xFFF; + sig += roundIncrement; + if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid; + z = sig>>12; + if ( + (roundBits == 0x800) && (roundingMode == softfloat_round_near_even) + ) { + z &= ~(uint_fast32_t) 1; + } + if ( sign && z ) goto invalid; + if ( roundBits ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) z |= 1; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return sign ? ui32_fromNegOverflow : ui32_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI64.c new file mode 100644 index 000000000..856ad9792 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_roundToUI64.c @@ -0,0 +1,97 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +uint_fast64_t + softfloat_roundToUI64( + bool sign, + uint_fast64_t sig, + uint_fast64_t sigExtra, + uint_fast8_t roundingMode, + bool exact + ) +{ + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( + (roundingMode == softfloat_round_near_maxMag) + || (roundingMode == softfloat_round_near_even) + ) { + if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment; + } else { + if ( sign ) { + if ( !(sig | sigExtra) ) return 0; + if ( roundingMode == softfloat_round_min ) goto invalid; +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) goto invalid; +#endif + } else { + if ( (roundingMode == softfloat_round_max) && sigExtra ) { + increment: + ++sig; + if ( !sig ) goto invalid; + if ( + (sigExtra == UINT64_C( 0x8000000000000000 )) + && (roundingMode == softfloat_round_near_even) + ) { + sig &= ~(uint_fast64_t) 1; + } + } + } + } + if ( sign && sig ) goto invalid; + if ( sigExtra ) { +#ifdef SOFTFLOAT_ROUND_ODD + if ( roundingMode == softfloat_round_odd ) sig |= 1; +#endif + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return sig; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftLeftM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftLeftM.c new file mode 100644 index 000000000..71a309919 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftLeftM.c @@ -0,0 +1,91 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_shiftLeftM + +#define softfloat_shiftLeftM softfloat_shiftLeftM +#include "primitives.h" + +void + softfloat_shiftLeftM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint32_t dist, + uint32_t *zPtr + ) +{ + uint32_t wordDist; + uint_fast8_t innerDist; + uint32_t *destPtr; + uint_fast8_t i; + + wordDist = dist>>5; + if ( wordDist < size_words ) { + aPtr += indexMultiwordLoBut( size_words, wordDist ); + innerDist = dist & 31; + if ( innerDist ) { + softfloat_shortShiftLeftM( + size_words - wordDist, + aPtr, + innerDist, + zPtr + indexMultiwordHiBut( size_words, wordDist ) + ); + if ( ! wordDist ) return; + } else { + aPtr += indexWordHi( size_words - wordDist ); + destPtr = zPtr + indexWordHi( size_words ); + for ( i = size_words - wordDist; i; --i ) { + *destPtr = *aPtr; + aPtr -= wordIncr; + destPtr -= wordIncr; + } + } + zPtr += indexMultiwordLo( size_words, wordDist ); + } else { + wordDist = size_words; + } + do { + *zPtr++ = 0; + --wordDist; + } while ( wordDist ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftNormSigF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftNormSigF128M.c new file mode 100644 index 000000000..fa4976c8e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftNormSigF128M.c @@ -0,0 +1,78 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" + +int + softfloat_shiftNormSigF128M( + const uint32_t *wPtr, uint_fast8_t shiftDist, uint32_t *sigPtr ) +{ + uint32_t wordSig; + int32_t exp; + uint32_t leadingBit; + + wordSig = wPtr[indexWordHi( 4 )]; + exp = expF128UI96( wordSig ); + if ( exp ) { + softfloat_shortShiftLeft128M( wPtr, shiftDist, sigPtr ); + leadingBit = 0x00010000< +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shiftRightJam128 + +struct uint128 + softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist ) +{ + uint_fast8_t u8NegDist; + struct uint128 z; + + if ( dist < 64 ) { + u8NegDist = -dist; + z.v64 = a64>>dist; + z.v0 = + a64<<(u8NegDist & 63) | a0>>dist + | ((uint64_t) (a0<<(u8NegDist & 63)) != 0); + } else { + z.v64 = 0; + z.v0 = + (dist < 127) + ? a64>>(dist & 63) + | (((a64 & (((uint_fast64_t) 1<<(dist & 63)) - 1)) | a0) + != 0) + : ((a64 | a0) != 0); + } + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam128Extra.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam128Extra.c new file mode 100644 index 000000000..75722887b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam128Extra.c @@ -0,0 +1,77 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shiftRightJam128Extra + +struct uint128_extra + softfloat_shiftRightJam128Extra( + uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist ) +{ + uint_fast8_t u8NegDist; + struct uint128_extra z; + + u8NegDist = -dist; + if ( dist < 64 ) { + z.v.v64 = a64>>dist; + z.v.v0 = a64<<(u8NegDist & 63) | a0>>dist; + z.extra = a0<<(u8NegDist & 63); + } else { + z.v.v64 = 0; + if ( dist == 64 ) { + z.v.v0 = a64; + z.extra = a0; + } else { + extra |= a0; + if ( dist < 128 ) { + z.v.v0 = a64>>(dist & 63); + z.extra = a64<<(u8NegDist & 63); + } else { + z.v.v0 = 0; + z.extra = (dist == 128) ? a64 : (a64 != 0); + } + } + } + z.extra |= (extra != 0); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam256M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam256M.c new file mode 100644 index 000000000..433870a81 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam256M.c @@ -0,0 +1,126 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shiftRightJam256M + +static + void + softfloat_shortShiftRightJamM( + uint_fast8_t size_words, + const uint64_t *aPtr, + uint_fast8_t dist, + uint64_t *zPtr + ) +{ + uint_fast8_t uNegDist; + unsigned int index, lastIndex; + uint64_t partWordZ, wordA; + + uNegDist = -dist; + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + wordA = aPtr[index]; + partWordZ = wordA>>dist; + if ( partWordZ<>dist; + } + zPtr[index] = partWordZ; + +} + +void + softfloat_shiftRightJam256M( + const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr ) +{ + uint64_t wordJam; + uint_fast32_t wordDist; + uint64_t *ptr; + uint_fast8_t i, innerDist; + + wordJam = 0; + wordDist = dist>>6; + if ( wordDist ) { + if ( 4 < wordDist ) wordDist = 4; + ptr = (uint64_t *) (aPtr + indexMultiwordLo( 4, wordDist )); + i = wordDist; + do { + wordJam = *ptr++; + if ( wordJam ) break; + --i; + } while ( i ); + ptr = zPtr; + } + if ( wordDist < 4 ) { + aPtr += indexMultiwordHiBut( 4, wordDist ); + innerDist = dist & 63; + if ( innerDist ) { + softfloat_shortShiftRightJamM( + 4 - wordDist, + aPtr, + innerDist, + zPtr + indexMultiwordLoBut( 4, wordDist ) + ); + if ( ! wordDist ) goto wordJam; + } else { + aPtr += indexWordLo( 4 - wordDist ); + ptr = zPtr + indexWordLo( 4 ); + for ( i = 4 - wordDist; i; --i ) { + *ptr = *aPtr; + aPtr += wordIncr; + ptr += wordIncr; + } + } + ptr = zPtr + indexMultiwordHi( 4, wordDist ); + } + do { + *ptr++ = 0; + --wordDist; + } while ( wordDist ); + wordJam: + if ( wordJam ) zPtr[indexWordLo( 4 )] |= 1; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam32.c new file mode 100644 index 000000000..2533fcd95 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam32.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_shiftRightJam32 + +uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist ) +{ + + return + (dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64.c new file mode 100644 index 000000000..4b40e3de6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_shiftRightJam64 + +uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist ) +{ + + return + (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64Extra.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64Extra.c new file mode 100644 index 000000000..b93fad39c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJam64Extra.c @@ -0,0 +1,62 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shiftRightJam64Extra + +struct uint64_extra + softfloat_shiftRightJam64Extra( + uint64_t a, uint64_t extra, uint_fast32_t dist ) +{ + struct uint64_extra z; + + if ( dist < 64 ) { + z.v = a>>dist; + z.extra = a<<(-dist & 63); + } else { + z.v = 0; + z.extra = (dist == 64) ? a : (a != 0); + } + z.extra |= (extra != 0); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJamM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJamM.c new file mode 100644 index 000000000..edf5f956b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightJamM.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_shiftRightJamM + +#define softfloat_shiftRightJamM softfloat_shiftRightJamM +#include "primitives.h" + +void + softfloat_shiftRightJamM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint32_t dist, + uint32_t *zPtr + ) +{ + uint32_t wordJam, wordDist, *ptr; + uint_fast8_t i, innerDist; + + wordJam = 0; + wordDist = dist>>5; + if ( wordDist ) { + if ( size_words < wordDist ) wordDist = size_words; + ptr = (uint32_t *) (aPtr + indexMultiwordLo( size_words, wordDist )); + i = wordDist; + do { + wordJam = *ptr++; + if ( wordJam ) break; + --i; + } while ( i ); + ptr = zPtr; + } + if ( wordDist < size_words ) { + aPtr += indexMultiwordHiBut( size_words, wordDist ); + innerDist = dist & 31; + if ( innerDist ) { + softfloat_shortShiftRightJamM( + size_words - wordDist, + aPtr, + innerDist, + zPtr + indexMultiwordLoBut( size_words, wordDist ) + ); + if ( ! wordDist ) goto wordJam; + } else { + aPtr += indexWordLo( size_words - wordDist ); + ptr = zPtr + indexWordLo( size_words ); + for ( i = size_words - wordDist; i; --i ) { + *ptr = *aPtr; + aPtr += wordIncr; + ptr += wordIncr; + } + } + ptr = zPtr + indexMultiwordHi( size_words, wordDist ); + } + do { + *ptr++ = 0; + --wordDist; + } while ( wordDist ); + wordJam: + if ( wordJam ) zPtr[indexWordLo( size_words )] |= 1; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightM.c new file mode 100644 index 000000000..00265ea23 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shiftRightM.c @@ -0,0 +1,91 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_shiftRightM + +#define softfloat_shiftRightM softfloat_shiftRightM +#include "primitives.h" + +void + softfloat_shiftRightM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint32_t dist, + uint32_t *zPtr + ) +{ + uint32_t wordDist; + uint_fast8_t innerDist; + uint32_t *destPtr; + uint_fast8_t i; + + wordDist = dist>>5; + if ( wordDist < size_words ) { + aPtr += indexMultiwordHiBut( size_words, wordDist ); + innerDist = dist & 31; + if ( innerDist ) { + softfloat_shortShiftRightM( + size_words - wordDist, + aPtr, + innerDist, + zPtr + indexMultiwordLoBut( size_words, wordDist ) + ); + if ( ! wordDist ) return; + } else { + aPtr += indexWordLo( size_words - wordDist ); + destPtr = zPtr + indexWordLo( size_words ); + for ( i = size_words - wordDist; i; --i ) { + *destPtr = *aPtr; + aPtr += wordIncr; + destPtr += wordIncr; + } + } + zPtr += indexMultiwordHi( size_words, wordDist ); + } else { + wordDist = size_words; + } + do { + *zPtr++ = 0; + --wordDist; + } while ( wordDist ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeft128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeft128.c new file mode 100644 index 000000000..7513bc627 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeft128.c @@ -0,0 +1,55 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftLeft128 + +struct uint128 + softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist ) +{ + struct uint128 z; + + z.v64 = a64<>(-dist & 63); + z.v0 = a0< +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftLeft64To96M + +void + softfloat_shortShiftLeft64To96M( + uint64_t a, uint_fast8_t dist, uint32_t *zPtr ) +{ + + zPtr[indexWord( 3, 0 )] = (uint32_t) a<>= 32 - dist; + zPtr[indexWord( 3, 2 )] = a>>32; + zPtr[indexWord( 3, 1 )] = a; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeftM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeftM.c new file mode 100644 index 000000000..48e6e03b5 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftLeftM.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftLeftM + +void + softfloat_shortShiftLeftM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint_fast8_t dist, + uint32_t *zPtr + ) +{ + uint_fast8_t uNegDist; + unsigned int index, lastIndex; + uint32_t partWordZ, wordA; + + uNegDist = -dist; + index = indexWordHi( size_words ); + lastIndex = indexWordLo( size_words ); + partWordZ = aPtr[index]<>(uNegDist & 31); + index -= wordIncr; + partWordZ = wordA< +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRight128 + +struct uint128 + softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist ) +{ + struct uint128 z; + + z.v64 = a64>>dist; + z.v0 = a64<<(-dist & 63) | a0>>dist; + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightExtendM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightExtendM.c new file mode 100644 index 000000000..bc441c731 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightExtendM.c @@ -0,0 +1,73 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRightExtendM + +void + softfloat_shortShiftRightExtendM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint_fast8_t dist, + uint32_t *zPtr + ) +{ + uint_fast8_t uNegDist; + unsigned int indexA, lastIndexA; + uint32_t partWordZ, wordA; + + uNegDist = -dist; + indexA = indexWordLo( size_words ); + lastIndexA = indexWordHi( size_words ); + zPtr += indexWordLo( size_words + 1 ); + partWordZ = 0; + for (;;) { + wordA = aPtr[indexA]; + *zPtr = wordA<<(uNegDist & 31) | partWordZ; + zPtr += wordIncr; + partWordZ = wordA>>dist; + if ( indexA == lastIndexA ) break; + indexA += wordIncr; + } + *zPtr = partWordZ; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128.c new file mode 100644 index 000000000..76008722b --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRightJam128 + +struct uint128 + softfloat_shortShiftRightJam128( + uint64_t a64, uint64_t a0, uint_fast8_t dist ) +{ + uint_fast8_t uNegDist; + struct uint128 z; + + uNegDist = -dist; + z.v64 = a64>>dist; + z.v0 = + a64<<(uNegDist & 63) | a0>>dist + | ((uint64_t) (a0<<(uNegDist & 63)) != 0); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128Extra.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128Extra.c new file mode 100644 index 000000000..b0774401d --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam128Extra.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRightJam128Extra + +struct uint128_extra + softfloat_shortShiftRightJam128Extra( + uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist ) +{ + uint_fast8_t uNegDist; + struct uint128_extra z; + + uNegDist = -dist; + z.v.v64 = a64>>dist; + z.v.v0 = a64<<(uNegDist & 63) | a0>>dist; + z.extra = a0<<(uNegDist & 63) | (extra != 0); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam64.c new file mode 100644 index 000000000..d3044c853 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJam64.c @@ -0,0 +1,50 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" + +#ifndef softfloat_shortShiftRightJam64 + +uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist ) +{ + + return a>>dist | ((a & (((uint_fast64_t) 1< +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRightJam64Extra + +struct uint64_extra + softfloat_shortShiftRightJam64Extra( + uint64_t a, uint64_t extra, uint_fast8_t dist ) +{ + struct uint64_extra z; + + z.v = a>>dist; + z.extra = a<<(-dist & 63) | (extra != 0); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJamM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJamM.c new file mode 100644 index 000000000..b567e482a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightJamM.c @@ -0,0 +1,72 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRightJamM + +void + softfloat_shortShiftRightJamM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint_fast8_t dist, + uint32_t *zPtr + ) +{ + uint_fast8_t uNegDist; + unsigned int index, lastIndex; + uint32_t partWordZ, wordA; + + uNegDist = -dist; + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + wordA = aPtr[index]; + partWordZ = wordA>>dist; + if ( partWordZ<>dist; + } + zPtr[index] = partWordZ; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightM.c new file mode 100644 index 000000000..54e0071c7 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_shortShiftRightM.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_shortShiftRightM + +void + softfloat_shortShiftRightM( + uint_fast8_t size_words, + const uint32_t *aPtr, + uint_fast8_t dist, + uint32_t *zPtr + ) +{ + uint_fast8_t uNegDist; + unsigned int index, lastIndex; + uint32_t partWordZ, wordA; + + uNegDist = -dist; + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + partWordZ = aPtr[index]>>dist; + while ( index != lastIndex ) { + wordA = aPtr[index + wordIncr]; + zPtr[index] = wordA<<(uNegDist & 31) | partWordZ; + index += wordIncr; + partWordZ = wordA>>dist; + } + zPtr[index] = partWordZ; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub128.c new file mode 100644 index 000000000..9bf346391 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub128.c @@ -0,0 +1,55 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_sub128 + +struct uint128 + softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + struct uint128 z; + + z.v0 = a0 - b0; + z.v64 = a64 - b64 - (a0 < b0); + return z; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub1XM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub1XM.c new file mode 100644 index 000000000..30c5d36ee --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub1XM.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_sub1XM + +void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr ) +{ + unsigned int index, lastIndex; + uint32_t wordA; + + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + for (;;) { + wordA = zPtr[index]; + zPtr[index] = wordA - 1; + if ( wordA || (index == lastIndex) ) break; + index += wordIncr; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub256M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub256M.c new file mode 100644 index 000000000..a4af5a1c9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_sub256M.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_sub256M + +void + softfloat_sub256M( + const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr ) +{ + unsigned int index; + uint_fast8_t borrow; + uint64_t wordA, wordB; + + index = indexWordLo( 4 ); + borrow = 0; + for (;;) { + wordA = aPtr[index]; + wordB = bPtr[index]; + zPtr[index] = wordA - wordB - borrow; + if ( index == indexWordHi( 4 ) ) break; + borrow = borrow ? (wordA <= wordB) : (wordA < wordB); + index += wordIncr; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subM.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subM.c new file mode 100644 index 000000000..fcccc744c --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subM.c @@ -0,0 +1,70 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "primitiveTypes.h" + +#ifndef softfloat_subM + +void + softfloat_subM( + uint_fast8_t size_words, + const uint32_t *aPtr, + const uint32_t *bPtr, + uint32_t *zPtr + ) +{ + unsigned int index, lastIndex; + uint_fast8_t borrow; + uint32_t wordA, wordB; + + index = indexWordLo( size_words ); + lastIndex = indexWordHi( size_words ); + borrow = 0; + for (;;) { + wordA = aPtr[index]; + wordB = bPtr[index]; + zPtr[index] = wordA - wordB - borrow; + if ( index == lastIndex ) break; + borrow = borrow ? (wordA <= wordB) : (wordA < wordB); + index += wordIncr; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsExtF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsExtF80.c new file mode 100644 index 000000000..0c46c61a2 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsExtF80.c @@ -0,0 +1,158 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +extFloat80_t + softfloat_subMagsExtF80( + uint_fast16_t uiA64, + uint_fast64_t uiA0, + uint_fast16_t uiB64, + uint_fast64_t uiB0, + bool signZ + ) +{ + int_fast32_t expA; + uint_fast64_t sigA; + int_fast32_t expB; + uint_fast64_t sigB; + int_fast32_t expDiff; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + int_fast32_t expZ; + uint_fast64_t sigExtra; + struct uint128 sig128, uiZ; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expExtF80UI64( uiA64 ); + sigA = uiA0; + expB = expExtF80UI64( uiB64 ); + sigB = uiB0; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( 0 < expDiff ) goto expABigger; + if ( expDiff < 0 ) goto expBBigger; + if ( expA == 0x7FFF ) { + if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + goto propagateNaN; + } + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ64 = defaultNaNExtF80UI64; + uiZ0 = defaultNaNExtF80UI0; + goto uiZ; + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expZ = expA; + if ( ! expZ ) expZ = 1; + sigExtra = 0; + if ( sigB < sigA ) goto aBigger; + if ( sigA < sigB ) goto bBigger; + uiZ64 = + packToExtF80UI64( (softfloat_roundingMode == softfloat_round_min), 0 ); + uiZ0 = 0; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expBBigger: + if ( expB == 0x7FFF ) { + if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + uiZ64 = packToExtF80UI64( signZ ^ 1, 0x7FFF ); + uiZ0 = UINT64_C( 0x8000000000000000 ); + goto uiZ; + } + if ( ! expA ) { + ++expDiff; + sigExtra = 0; + if ( ! expDiff ) goto newlyAlignedBBigger; + } + sig128 = softfloat_shiftRightJam128( sigA, 0, -expDiff ); + sigA = sig128.v64; + sigExtra = sig128.v0; + newlyAlignedBBigger: + expZ = expB; + bBigger: + signZ = ! signZ; + sig128 = softfloat_sub128( sigB, 0, sigA, sigExtra ); + goto normRoundPack; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expABigger: + if ( expA == 0x7FFF ) { + if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN; + uiZ64 = uiA64; + uiZ0 = uiA0; + goto uiZ; + } + if ( ! expB ) { + --expDiff; + sigExtra = 0; + if ( ! expDiff ) goto newlyAlignedABigger; + } + sig128 = softfloat_shiftRightJam128( sigB, 0, expDiff ); + sigB = sig128.v64; + sigExtra = sig128.v0; + newlyAlignedABigger: + expZ = expA; + aBigger: + sig128 = softfloat_sub128( sigA, 0, sigB, sigExtra ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + normRoundPack: + return + softfloat_normRoundPackToExtF80( + signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 ); + uiZ64 = uiZ.v64; + uiZ0 = uiZ.v0; + uiZ: + uZ.s.signExp = uiZ64; + uZ.s.signif = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF128.c new file mode 100644 index 000000000..e93543f09 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF128.c @@ -0,0 +1,139 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float128_t + softfloat_subMagsF128( + uint_fast64_t uiA64, + uint_fast64_t uiA0, + uint_fast64_t uiB64, + uint_fast64_t uiB0, + bool signZ + ) +{ + int_fast32_t expA; + struct uint128 sigA; + int_fast32_t expB; + struct uint128 sigB, sigZ; + int_fast32_t expDiff, expZ; + struct uint128 uiZ; + union ui128_f128 uZ; + + expA = expF128UI64( uiA64 ); + sigA.v64 = fracF128UI64( uiA64 ); + sigA.v0 = uiA0; + expB = expF128UI64( uiB64 ); + sigB.v64 = fracF128UI64( uiB64 ); + sigB.v0 = uiB0; + sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 4 ); + sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 4 ); + expDiff = expA - expB; + if ( 0 < expDiff ) goto expABigger; + if ( expDiff < 0 ) goto expBBigger; + if ( expA == 0x7FFF ) { + if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN; + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ.v64 = defaultNaNF128UI64; + uiZ.v0 = defaultNaNF128UI0; + goto uiZ; + } + expZ = expA; + if ( ! expZ ) expZ = 1; + if ( sigB.v64 < sigA.v64 ) goto aBigger; + if ( sigA.v64 < sigB.v64 ) goto bBigger; + if ( sigB.v0 < sigA.v0 ) goto aBigger; + if ( sigA.v0 < sigB.v0 ) goto bBigger; + uiZ.v64 = + packToF128UI64( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + uiZ.v0 = 0; + goto uiZ; + expBBigger: + if ( expB == 0x7FFF ) { + if ( sigB.v64 | sigB.v0 ) goto propagateNaN; + uiZ.v64 = packToF128UI64( signZ ^ 1, 0x7FFF, 0 ); + uiZ.v0 = 0; + goto uiZ; + } + if ( expA ) { + sigA.v64 |= UINT64_C( 0x0010000000000000 ); + } else { + ++expDiff; + if ( ! expDiff ) goto newlyAlignedBBigger; + } + sigA = softfloat_shiftRightJam128( sigA.v64, sigA.v0, -expDiff ); + newlyAlignedBBigger: + expZ = expB; + sigB.v64 |= UINT64_C( 0x0010000000000000 ); + bBigger: + signZ = ! signZ; + sigZ = softfloat_sub128( sigB.v64, sigB.v0, sigA.v64, sigA.v0 ); + goto normRoundPack; + expABigger: + if ( expA == 0x7FFF ) { + if ( sigA.v64 | sigA.v0 ) goto propagateNaN; + uiZ.v64 = uiA64; + uiZ.v0 = uiA0; + goto uiZ; + } + if ( expB ) { + sigB.v64 |= UINT64_C( 0x0010000000000000 ); + } else { + --expDiff; + if ( ! expDiff ) goto newlyAlignedABigger; + } + sigB = softfloat_shiftRightJam128( sigB.v64, sigB.v0, expDiff ); + newlyAlignedABigger: + expZ = expA; + sigA.v64 |= UINT64_C( 0x0010000000000000 ); + aBigger: + sigZ = softfloat_sub128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 ); + normRoundPack: + return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 ); + propagateNaN: + uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF16.c new file mode 100644 index 000000000..ae1417ea9 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF16.c @@ -0,0 +1,187 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB ) +{ + int_fast8_t expA; + uint_fast16_t sigA; + int_fast8_t expB; + uint_fast16_t sigB; + int_fast8_t expDiff; + uint_fast16_t uiZ; + int_fast16_t sigDiff; + bool signZ; + int_fast8_t shiftDist, expZ; + uint_fast16_t sigZ, sigX, sigY; + uint_fast32_t sig32Z; + int_fast8_t roundingMode; + union ui16_f16 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expF16UI( uiA ); + sigA = fracF16UI( uiA ); + expB = expF16UI( uiB ); + sigB = fracF16UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( ! expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expA == 0x1F ) { + if ( sigA | sigB ) goto propagateNaN; + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF16UI; + goto uiZ; + } + sigDiff = sigA - sigB; + if ( ! sigDiff ) { + uiZ = + packToF16UI( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + goto uiZ; + } + if ( expA ) --expA; + signZ = signF16UI( uiA ); + if ( sigDiff < 0 ) { + signZ = ! signZ; + sigDiff = -sigDiff; + } + shiftDist = softfloat_countLeadingZeros16( sigDiff ) - 5; + expZ = expA - shiftDist; + if ( expZ < 0 ) { + shiftDist = expA; + expZ = 0; + } + sigZ = sigDiff<>16; + if ( sig32Z & 0xFFFF ) { + sigZ |= 1; + } else { + if ( ! (sigZ & 0xF) && ((unsigned int) expZ < 0x1E) ) { + sigZ >>= 4; + goto pack; + } + } + return softfloat_roundPackToF16( signZ, expZ, sigZ ); + } + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + propagateNaN: + uiZ = softfloat_propagateNaNF16UI( uiA, uiB ); + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + subEpsilon: + roundingMode = softfloat_roundingMode; + if ( roundingMode != softfloat_round_near_even ) { + if ( + (roundingMode == softfloat_round_minMag) + || (roundingMode + == (signF16UI( uiZ ) ? softfloat_round_max + : softfloat_round_min)) + ) { + --uiZ; + } +#ifdef SOFTFLOAT_ROUND_ODD + else if ( roundingMode == softfloat_round_odd ) { + uiZ = (uiZ - 1) | 1; + } +#endif + } + softfloat_exceptionFlags |= softfloat_flag_inexact; + goto uiZ; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + pack: + uiZ = packToF16UI( signZ, expZ, sigZ ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF32.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF32.c new file mode 100644 index 000000000..0c1f32ed6 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_subMagsF32.c @@ -0,0 +1,143 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB ) +{ + int_fast16_t expA; + uint_fast32_t sigA; + int_fast16_t expB; + uint_fast32_t sigB; + int_fast16_t expDiff; + uint_fast32_t uiZ; + int_fast32_t sigDiff; + bool signZ; + int_fast8_t shiftDist; + int_fast16_t expZ; + uint_fast32_t sigX, sigY; + union ui32_f32 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( ! expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expA == 0xFF ) { + if ( sigA | sigB ) goto propagateNaN; + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + goto uiZ; + } + sigDiff = sigA - sigB; + if ( ! sigDiff ) { + uiZ = + packToF32UI( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + goto uiZ; + } + if ( expA ) --expA; + signZ = signF32UI( uiA ); + if ( sigDiff < 0 ) { + signZ = ! signZ; + sigDiff = -sigDiff; + } + shiftDist = softfloat_countLeadingZeros32( sigDiff ) - 8; + expZ = expA - shiftDist; + if ( expZ < 0 ) { + shiftDist = expA; + expZ = 0; + } + uiZ = packToF32UI( signZ, expZ, sigDiff< +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t + softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ ) +{ + int_fast16_t expA; + uint_fast64_t sigA; + int_fast16_t expB; + uint_fast64_t sigB; + int_fast16_t expDiff; + uint_fast64_t uiZ; + int_fast64_t sigDiff; + int_fast8_t shiftDist; + int_fast16_t expZ; + uint_fast64_t sigZ; + union ui64_f64 uZ; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + expDiff = expA - expB; + if ( ! expDiff ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + if ( expA == 0x7FF ) { + if ( sigA | sigB ) goto propagateNaN; + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + goto uiZ; + } + sigDiff = sigA - sigB; + if ( ! sigDiff ) { + uiZ = + packToF64UI( + (softfloat_roundingMode == softfloat_round_min), 0, 0 ); + goto uiZ; + } + if ( expA ) --expA; + if ( sigDiff < 0 ) { + signZ = ! signZ; + sigDiff = -sigDiff; + } + shiftDist = softfloat_countLeadingZeros64( sigDiff ) - 11; + expZ = expA - shiftDist; + if ( expZ < 0 ) { + shiftDist = expA; + expZ = 0; + } + uiZ = packToF64UI( signZ, expZ, sigDiff< +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +bool + softfloat_tryPropagateNaNExtF80M( + const struct extFloat80M *aSPtr, + const struct extFloat80M *bSPtr, + struct extFloat80M *zSPtr + ) +{ + uint_fast16_t ui64; + uint64_t ui0; + + ui64 = aSPtr->signExp; + ui0 = aSPtr->signif; + if ( isNaNExtF80UI( ui64, ui0 ) ) goto propagateNaN; + ui64 = bSPtr->signExp; + ui0 = bSPtr->signif; + if ( isNaNExtF80UI( ui64, ui0 ) ) goto propagateNaN; + return false; + propagateNaN: + softfloat_propagateNaNExtF80M( aSPtr, bSPtr, zSPtr ); + return true; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_tryPropagateNaNF128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_tryPropagateNaNF128M.c new file mode 100644 index 000000000..bab04a7c0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/s_tryPropagateNaNF128M.c @@ -0,0 +1,55 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" + +bool + softfloat_tryPropagateNaNF128M( + const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr ) +{ + + if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) { + softfloat_propagateNaNF128M( aWPtr, bWPtr, zWPtr ); + return true; + } + return false; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/softfloat_state.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/softfloat_state.c new file mode 100644 index 000000000..0f296654f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/softfloat_state.c @@ -0,0 +1,52 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +#ifndef THREAD_LOCAL +#define THREAD_LOCAL +#endif + +THREAD_LOCAL uint_fast8_t softfloat_roundingMode = softfloat_round_near_even; +THREAD_LOCAL uint_fast8_t softfloat_detectTininess = init_detectTininess; +THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags = 0; + +THREAD_LOCAL uint_fast8_t extF80_roundingPrecision = 80; + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80.c new file mode 100644 index 000000000..34f79368f --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +extFloat80_t ui32_to_extF80( uint32_t a ) +{ + uint_fast16_t uiZ64; + int_fast8_t shiftDist; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + uiZ64 = 0; + if ( a ) { + shiftDist = softfloat_countLeadingZeros32( a ); + uiZ64 = 0x401E - shiftDist; + a <<= shiftDist; + } + uZ.s.signExp = uiZ64; + uZ.s.signif = (uint_fast64_t) a<<32; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80M.c new file mode 100644 index 000000000..0a0c098c0 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_extF80M.c @@ -0,0 +1,74 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr ) +{ + + *zPtr = ui32_to_extF80( a ); + +} + +#else + +void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + uint_fast16_t uiZ64; + uint64_t sigZ; + int_fast8_t shiftDist; + + zSPtr = (struct extFloat80M *) zPtr; + uiZ64 = 0; + sigZ = 0; + if ( a ) { + shiftDist = softfloat_countLeadingZeros32( a ); + uiZ64 = packToExtF80UI64( 0, 0x401E - shiftDist ); + sigZ = (uint64_t) (a<signExp = uiZ64; + zSPtr->signif = sigZ; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f128.c new file mode 100644 index 000000000..c3ab53daf --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f128.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t ui32_to_f128( uint32_t a ) +{ + uint_fast64_t uiZ64; + int_fast8_t shiftDist; + union ui128_f128 uZ; + + uiZ64 = 0; + if ( a ) { + shiftDist = softfloat_countLeadingZeros32( a ) + 17; + uiZ64 = + packToF128UI64( + 0, 0x402E - shiftDist, (uint_fast64_t) a< +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void ui32_to_f128M( uint32_t a, float128_t *zPtr ) +{ + + *zPtr = ui32_to_f128( a ); + +} + +#else + +void ui32_to_f128M( uint32_t a, float128_t *zPtr ) +{ + uint32_t *zWPtr, uiZ96, uiZ64; + int_fast8_t shiftDist; + uint64_t normA; + + zWPtr = (uint32_t *) zPtr; + uiZ96 = 0; + uiZ64 = 0; + if ( a ) { + shiftDist = softfloat_countLeadingZeros32( a ) + 17; + normA = (uint64_t) a<>32 ); + uiZ64 = normA; + } + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = uiZ64; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f16.c new file mode 100644 index 000000000..6fc377bca --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f16.c @@ -0,0 +1,65 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t ui32_to_f16( uint32_t a ) +{ + int_fast8_t shiftDist; + union ui16_f16 u; + uint_fast16_t sig; + + shiftDist = softfloat_countLeadingZeros32( a ) - 21; + if ( 0 <= shiftDist ) { + u.ui = + a ? packToF16UI( + 0, 0x18 - shiftDist, (uint_fast16_t) a<>(-shiftDist) | ((uint32_t) (a<<(shiftDist & 31)) != 0) + : (uint_fast16_t) a< +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t ui32_to_f32( uint32_t a ) +{ + union ui32_f32 uZ; + + if ( ! a ) { + uZ.ui = 0; + return uZ.f; + } + if ( a & 0x80000000 ) { + return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) ); + } else { + return softfloat_normRoundPackToF32( 0, 0x9C, a ); + } + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f64.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f64.c new file mode 100644 index 000000000..504f96e6e --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui32_to_f64.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t ui32_to_f64( uint32_t a ) +{ + uint_fast64_t uiZ; + int_fast8_t shiftDist; + union ui64_f64 uZ; + + if ( ! a ) { + uiZ = 0; + } else { + shiftDist = softfloat_countLeadingZeros32( a ) + 21; + uiZ = + packToF64UI( 0, 0x432 - shiftDist, (uint_fast64_t) a< +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +extFloat80_t ui64_to_extF80( uint64_t a ) +{ + uint_fast16_t uiZ64; + int_fast8_t shiftDist; + union { struct extFloat80M s; extFloat80_t f; } uZ; + + uiZ64 = 0; + if ( a ) { + shiftDist = softfloat_countLeadingZeros64( a ); + uiZ64 = 0x403E - shiftDist; + a <<= shiftDist; + } + uZ.s.signExp = uiZ64; + uZ.s.signif = a; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_extF80M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_extF80M.c new file mode 100644 index 000000000..e676d904a --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_extF80M.c @@ -0,0 +1,74 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr ) +{ + + *zPtr = ui64_to_extF80( a ); + +} + +#else + +void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + uint_fast16_t uiZ64; + uint64_t sigZ; + int_fast8_t shiftDist; + + zSPtr = (struct extFloat80M *) zPtr; + uiZ64 = 0; + sigZ = 0; + if ( a ) { + shiftDist = softfloat_countLeadingZeros64( a ); + uiZ64 = packToExtF80UI64( 0, 0x403E - shiftDist ); + sigZ = a<signExp = uiZ64; + zSPtr->signif = sigZ; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128.c new file mode 100644 index 000000000..6ff6a6fcf --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128.c @@ -0,0 +1,68 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float128_t ui64_to_f128( uint64_t a ) +{ + uint_fast64_t uiZ64, uiZ0; + int_fast8_t shiftDist; + struct uint128 zSig; + union ui128_f128 uZ; + + if ( ! a ) { + uiZ64 = 0; + uiZ0 = 0; + } else { + shiftDist = softfloat_countLeadingZeros64( a ) + 49; + if ( 64 <= shiftDist ) { + zSig.v64 = a<<(shiftDist - 64); + zSig.v0 = 0; + } else { + zSig = softfloat_shortShiftLeft128( 0, a, shiftDist ); + } + uiZ64 = packToF128UI64( 0, 0x406E - shiftDist, zSig.v64 ); + uiZ0 = zSig.v0; + } + uZ.ui.v64 = uiZ64; + uZ.ui.v0 = uiZ0; + return uZ.f; + +} + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128M.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128M.c new file mode 100644 index 000000000..043406cc4 --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f128M.c @@ -0,0 +1,86 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +#ifdef SOFTFLOAT_FAST_INT64 + +void ui64_to_f128M( uint64_t a, float128_t *zPtr ) +{ + + *zPtr = ui64_to_f128( a ); + +} + +#else + +void ui64_to_f128M( uint64_t a, float128_t *zPtr ) +{ + uint32_t *zWPtr, uiZ96, uiZ64; + uint_fast8_t shiftDist; + uint32_t *ptr; + + zWPtr = (uint32_t *) zPtr; + uiZ96 = 0; + uiZ64 = 0; + zWPtr[indexWord( 4, 1 )] = 0; + zWPtr[indexWord( 4, 0 )] = 0; + if ( a ) { + shiftDist = softfloat_countLeadingZeros64( a ) + 17; + if ( shiftDist < 32 ) { + ptr = zWPtr + indexMultiwordHi( 4, 3 ); + ptr[indexWord( 3, 2 )] = 0; + ptr[indexWord( 3, 1 )] = a>>32; + ptr[indexWord( 3, 0 )] = a; + softfloat_shortShiftLeft96M( ptr, shiftDist, ptr ); + ptr[indexWordHi( 3 )] = + packToF128UI96( 0, 0x404E - shiftDist, ptr[indexWordHi( 3 )] ); + return; + } + a <<= shiftDist - 32; + uiZ96 = packToF128UI96( 0, 0x404E - shiftDist, a>>32 ); + uiZ64 = a; + } + zWPtr[indexWord( 4, 3 )] = uiZ96; + zWPtr[indexWord( 4, 2 )] = uiZ64; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f16.c b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f16.c new file mode 100644 index 000000000..3d58e85cf --- /dev/null +++ b/wally-pipelined/testbench/fp/SoftFloat-3e/source/ui64_to_f16.c @@ -0,0 +1,64 @@ + +/*============================================================================ + +This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic +Package, Release 3e, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All Rights Reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float16_t ui64_to_f16( uint64_t a ) +{ + int_fast8_t shiftDist; + union ui16_f16 u; + uint_fast16_t sig; + + shiftDist = softfloat_countLeadingZeros64( a ) - 53; + if ( 0 <= shiftDist ) { + u.ui = + a ? packToF16UI( + 0, 0x18 - shiftDist, (uint_fast16_t) a< +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t ui64_to_f32( uint64_t a ) +{ + int_fast8_t shiftDist; + union ui32_f32 u; + uint_fast32_t sig; + + shiftDist = softfloat_countLeadingZeros64( a ) - 40; + if ( 0 <= shiftDist ) { + u.ui = + a ? packToF32UI( + 0, 0x95 - shiftDist, (uint_fast32_t) a< +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t ui64_to_f64( uint64_t a ) +{ + union ui64_f64 uZ; + + if ( ! a ) { + uZ.ui = 0; + return uZ.f; + } + if ( a & UINT64_C( 0x8000000000000000 ) ) { + return + softfloat_roundPackToF64( + 0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) ); + } else { + return softfloat_normRoundPackToF64( 0, 0x43C, a ); + } + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/COPYING.txt b/wally-pipelined/testbench/fp/TestFloat-3e/COPYING.txt new file mode 100644 index 000000000..c7443450e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/COPYING.txt @@ -0,0 +1,37 @@ + +License for Berkeley TestFloat Release 3e + +John R. Hauser +2018 January 20 + +The following applies to the whole of TestFloat Release 3e as well as to +each source file individually. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions, and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/README.html b/wally-pipelined/testbench/fp/TestFloat-3e/README.html new file mode 100644 index 000000000..251408cbd --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/README.html @@ -0,0 +1,82 @@ + + + + +Berkeley TestFloat Package Overview + + + + +

Package Overview for Berkeley TestFloat Release 3e

+ +

+John R. Hauser
+2018 January 20
+

+ +

+Berkeley TestFloat is a small collection of programs for testing that an +implementation of binary floating-point conforms to the IEEE Standard for +Floating-Point Arithmetic. +TestFloat is distributed in the form of C source code. +

+ +

+The TestFloat package is documented in the following files in the +doc subdirectory: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TestFloat-general.html +General documentation for understanding and using the TestFloat programs. +
testfloat_gen.html +Specific documentation for the testfloat_gen program. +
testfloat_ver.html +Specific documentation for the testfloat_ver program. +
testfloat.html +Specific documentation for the all-in-one testfloat program. +
testsoftfloat.html +Specific documentation for the testsoftfloat program. +
timesoftfloat.html +Specific documentation for the timesoftfloat program. +
TestFloat-source.html +Documentation for building TestFloat. +
TestFloat-history.html    +History of the major changes to TestFloat. +
+
+Other files in the package comprise the source code for TestFloat. +

+ + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/README.txt b/wally-pipelined/testbench/fp/TestFloat-3e/README.txt new file mode 100644 index 000000000..f2c33db31 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/README.txt @@ -0,0 +1,26 @@ + +Package Overview for Berkeley TestFloat Release 3e + +John R. Hauser +2018 January 20 + +Berkeley TestFloat is a small collection of programs for testing that an +implementation of binary floating-point conforms to the IEEE Standard for +Floating-Point Arithmetic. TestFloat is distributed in the form of C source +code. + +The TestFloat package is documented in the following files in the "doc" +subdirectory: + + TestFloat-general.html General documentation for understanding and using + the TestFloat programs. + testfloat_gen.html \ + testfloat_ver.html | Specific documentation for each TestFloat + testfloat.html | program. + testsoftfloat.html | + timesoftfloat.html / + TestFloat-source.html Documentation for building TestFloat. + TestFloat-history.html History of the major changes to TestFloat. + +Other files in the package comprise the source code for TestFloat. + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/Makefile new file mode 100644 index 000000000..440830dea --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/Makefile @@ -0,0 +1,355 @@ + +#============================================================================= +# +# This Makefile is part of TestFloat, Release 3e, a package of programs for +# testing the correctness of floating-point arithmetic complying with the IEEE +# Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +PLATFORM ?= Linux-386-GCC + +SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +SOFTFLOAT_H = \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +TESTFLOAT_OPTS ?= \ + -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD \ + -DLONG_DOUBLE_IS_EXTFLOAT80 + +DELETE = rm -f +C_INCLUDES = \ + -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +COMPILE_SLOWFLOAT_C = \ + gcc -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O3 -o $@ +MAKELIB = ar crs $@ +LINK = gcc -o $@ +OTHER_LIBS = -lm + +OBJ = .o +LIB = .a +EXE = + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/platform.h new file mode 100644 index 000000000..3ccb35e9b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-GCC/platform.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/Makefile new file mode 100644 index 000000000..2d0a667af --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/Makefile @@ -0,0 +1,355 @@ + +#============================================================================= +# +# This Makefile is part of TestFloat, Release 3e, a package of programs for +# testing the correctness of floating-point arithmetic complying with the IEEE +# Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +PLATFORM ?= Linux-386-SSE2-GCC + +SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +SOFTFLOAT_H = \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +TESTFLOAT_OPTS ?= \ + -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD \ + -DLONG_DOUBLE_IS_EXTFLOAT80 + +DELETE = rm -f +C_INCLUDES = \ + -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration -msse2 -mfpmath=sse \ + $(TESTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +COMPILE_SLOWFLOAT_C = \ + gcc -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O3 -o $@ +MAKELIB = ar crs $@ +LINK = gcc -o $@ +OTHER_LIBS = -lm + +OBJ = .o +LIB = .a +EXE = + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/platform.h new file mode 100644 index 000000000..3ccb35e9b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-386-SSE2-GCC/platform.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile new file mode 100644 index 000000000..37c979c46 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/Makefile @@ -0,0 +1,353 @@ + +#============================================================================= +# +# This Makefile is part of TestFloat, Release 3e, a package of programs for +# testing the correctness of floating-point arithmetic complying with the IEEE +# Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +PLATFORM ?= Linux-ARM-VFPv2-GCC + +SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +SOFTFLOAT_H = \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +TESTFLOAT_OPTS ?= -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD + +DELETE = rm -f +C_INCLUDES = \ + -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +COMPILE_C = \ + gcc -std=c99 -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +COMPILE_SLOWFLOAT_C = \ + gcc -std=c99 -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O3 -o $@ +MAKELIB = ar crs $@ +LINK = gcc -o $@ +OTHER_LIBS = -lm + +OBJ = .o +LIB = .a +EXE = + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h new file mode 100644 index 000000000..3ccb35e9b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-ARM-VFPv2-GCC/platform.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/Makefile new file mode 100644 index 000000000..65ad2d89d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/Makefile @@ -0,0 +1,355 @@ + +#============================================================================= +# +# This Makefile is part of TestFloat, Release 3e, a package of programs for +# testing the correctness of floating-point arithmetic complying with the IEEE +# Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +PLATFORM ?= Linux-x86_64-GCC + +SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +SOFTFLOAT_H = \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +TESTFLOAT_OPTS ?= \ + -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD \ + -DLONG_DOUBLE_IS_EXTFLOAT80 + +DELETE = rm -f +C_INCLUDES = \ + -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +COMPILE_C = \ + gcc -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +COMPILE_SLOWFLOAT_C = \ + gcc -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O3 -o $@ +MAKELIB = ar crs $@ +LINK = gcc -o $@ +OTHER_LIBS = -lm + +OBJ = .o +LIB = .a +EXE = + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/platform.h new file mode 100644 index 000000000..3ccb35e9b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Linux-x86_64-GCC/platform.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/Makefile new file mode 100644 index 000000000..bfc0670b6 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/Makefile @@ -0,0 +1,355 @@ + +#============================================================================= +# +# This Makefile is part of TestFloat, Release 3e, a package of programs for +# testing the correctness of floating-point arithmetic complying with the IEEE +# Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +PLATFORM ?= Win32-MinGW + +SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +SOFTFLOAT_H = \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +TESTFLOAT_OPTS ?= \ + -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD \ + -DLONG_DOUBLE_IS_EXTFLOAT80 + +DELETE = rm -f +C_INCLUDES = \ + -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +COMPILE_C = \ + gcc -std=c99 -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O2 -o $@ +COMPILE_SLOWFLOAT_C = \ + gcc -std=c99 -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O3 -o $@ +MAKELIB = ar crs $@ +LINK = gcc -o $@ +OTHER_LIBS = -lm + +OBJ = .o +LIB = .a +EXE = .exe + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/platform.h new file mode 100644 index 000000000..3ccb35e9b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-MinGW/platform.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/Makefile new file mode 100644 index 000000000..5e0acba91 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/Makefile @@ -0,0 +1,355 @@ + +#============================================================================= +# +# This Makefile is part of TestFloat, Release 3e, a package of programs for +# testing the correctness of floating-point arithmetic complying with the IEEE +# Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +PLATFORM ?= Win32-SSE2-MinGW + +SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +SOFTFLOAT_H = \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +TESTFLOAT_OPTS ?= \ + -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD \ + -DLONG_DOUBLE_IS_EXTFLOAT80 + +DELETE = rm -f +C_INCLUDES = \ + -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +COMPILE_C = \ + gcc -std=c99 -c -Werror-implicit-function-declaration -msse2 -mfpmath=sse \ + $(TESTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +COMPILE_SLOWFLOAT_C = \ + gcc -std=c99 -c -Werror-implicit-function-declaration $(TESTFLOAT_OPTS) \ + $(C_INCLUDES) -O3 -o $@ +MAKELIB = ar crs $@ +LINK = gcc -o $@ +OTHER_LIBS = -lm + +OBJ = .o +LIB = .a +EXE = .exe + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/platform.h new file mode 100644 index 000000000..3ccb35e9b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win32-SSE2-MinGW/platform.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/Makefile new file mode 100644 index 000000000..914266904 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/Makefile @@ -0,0 +1,355 @@ + +#============================================================================= +# +# This Makefile is part of TestFloat, Release 3e, a package of programs for +# testing the correctness of floating-point arithmetic complying with the IEEE +# Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +SOURCE_DIR ?= ../../source +SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +PLATFORM ?= Win64-MinGW-w64 + +SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +SOFTFLOAT_H = \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ + $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +TESTFLOAT_OPTS ?= \ + -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD \ + -DLONG_DOUBLE_IS_EXTFLOAT80 + +DELETE = rm -f +C_INCLUDES = \ + -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +COMPILE_C = \ + x86_64-w64-mingw32-gcc -std=c99 -c -Werror-implicit-function-declaration \ + $(TESTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +COMPILE_SLOWFLOAT_C = \ + x86_64-w64-mingw32-gcc -std=c99 -c -Werror-implicit-function-declaration \ + $(TESTFLOAT_OPTS) $(C_INCLUDES) -O3 -o $@ +MAKELIB = x86_64-w64-mingw32-ar crs $@ +LINK = x86_64-w64-mingw32-gcc -o $@ +OTHER_LIBS = -lm + +OBJ = .o +LIB = .a +EXE = .exe + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/platform.h new file mode 100644 index 000000000..3ccb35e9b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/Win64-MinGW-w64/platform.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef __GNUC_STDC_INLINE__ +#define INLINE inline +#else +#define INLINE extern inline +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/template/Makefile b/wally-pipelined/testbench/fp/TestFloat-3e/build/template/Makefile new file mode 100644 index 000000000..f5c3b602f --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/template/Makefile @@ -0,0 +1,353 @@ + +#============================================================================= +# +# This Makefile template is part of TestFloat, Release 3e, a package of +# programs for testing the correctness of floating-point arithmetic complying +# with the IEEE Standard for Floating-Point, by John R. Hauser. +# +# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +# University of California. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions, and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions, and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the University nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +#============================================================================= + +# Edit lines marked with `==>'. See "TestFloat-source.html". + +==> SOURCE_DIR ?= ../../source +==> SOFTFLOAT_DIR ?= ../../../SoftFloat-3e +==> PLATFORM ?= Win32-MinGW + +==> SUBJ_SOURCE_DIR = $(SOURCE_DIR)/subj-C +==> SOFTFLOAT_INCLUDE_DIR = $(SOFTFLOAT_DIR)/source/include + +==> SOFTFLOAT_H = \ +==> $(SOFTFLOAT_INCLUDE_DIR)/softfloat_types.h \ +==> $(SOFTFLOAT_INCLUDE_DIR)/softfloat.h +==> SOFTFLOAT_LIB = $(SOFTFLOAT_DIR)/build/$(PLATFORM)/softfloat$(LIB) + +==> TESTFLOAT_OPTS ?= \ +==> -DFLOAT16 -DFLOAT64 -DEXTFLOAT80 -DFLOAT128 -DFLOAT_ROUND_ODD \ +==> -DLONG_DOUBLE_IS_EXTFLOAT80 + +==> DELETE = rm -f +==> C_INCLUDES = \ +==> -I. -I$(SUBJ_SOURCE_DIR) -I$(SOURCE_DIR) -I$(SOFTFLOAT_INCLUDE_DIR) +==> COMPILE_C = cc -c $(TESTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@ +==> COMPILE_SLOWFLOAT_C = cc -c $(TESTFLOAT_OPTS) $(C_INCLUDES) -O3 -o $@ +==> MAKELIB = ar crs $@ +==> LINK = ld -o $@ +==> OTHER_LIBS = -lm + +==> OBJ = .o +==> LIB = .a +==> EXE = .exe + +.PHONY: all +all: \ + testsoftfloat$(EXE) \ + timesoftfloat$(EXE) \ + testfloat_gen$(EXE) \ + testfloat_ver$(EXE) \ + testfloat$(EXE) \ + +OBJS_GENCASES = \ + genCases_ui32$(OBJ) \ + genCases_ui64$(OBJ) \ + genCases_i32$(OBJ) \ + genCases_i64$(OBJ) \ + genCases_f16$(OBJ) \ + genCases_f32$(OBJ) \ + genCases_f64$(OBJ) \ + genCases_extF80$(OBJ) \ + genCases_f128$(OBJ) \ + +OBJS_WRITECASE = \ + writeCase_a_ui32$(OBJ) \ + writeCase_a_ui64$(OBJ) \ + writeCase_a_f16$(OBJ) \ + writeCase_ab_f16$(OBJ) \ + writeCase_abc_f16$(OBJ) \ + writeCase_a_f32$(OBJ) \ + writeCase_ab_f32$(OBJ) \ + writeCase_abc_f32$(OBJ) \ + writeCase_a_f64$(OBJ) \ + writeCase_ab_f64$(OBJ) \ + writeCase_abc_f64$(OBJ) \ + writeCase_a_extF80M$(OBJ) \ + writeCase_ab_extF80M$(OBJ) \ + writeCase_a_f128M$(OBJ) \ + writeCase_ab_f128M$(OBJ) \ + writeCase_abc_f128M$(OBJ) \ + writeCase_z_bool$(OBJ) \ + writeCase_z_ui32$(OBJ) \ + writeCase_z_ui64$(OBJ) \ + writeCase_z_f16$(OBJ) \ + writeCase_z_f32$(OBJ) \ + writeCase_z_f64$(OBJ) \ + writeCase_z_extF80M$(OBJ) \ + writeCase_z_f128M$(OBJ) \ + +OBJS_TEST = \ + test_a_ui32_z_f16$(OBJ) \ + test_a_ui32_z_f32$(OBJ) \ + test_a_ui32_z_f64$(OBJ) \ + test_a_ui32_z_extF80$(OBJ) \ + test_a_ui32_z_f128$(OBJ) \ + test_a_ui64_z_f16$(OBJ) \ + test_a_ui64_z_f32$(OBJ) \ + test_a_ui64_z_f64$(OBJ) \ + test_a_ui64_z_extF80$(OBJ) \ + test_a_ui64_z_f128$(OBJ) \ + test_a_i32_z_f16$(OBJ) \ + test_a_i32_z_f32$(OBJ) \ + test_a_i32_z_f64$(OBJ) \ + test_a_i32_z_extF80$(OBJ) \ + test_a_i32_z_f128$(OBJ) \ + test_a_i64_z_f16$(OBJ) \ + test_a_i64_z_f32$(OBJ) \ + test_a_i64_z_f64$(OBJ) \ + test_a_i64_z_extF80$(OBJ) \ + test_a_i64_z_f128$(OBJ) \ + test_a_f16_z_ui32_rx$(OBJ) \ + test_a_f16_z_ui64_rx$(OBJ) \ + test_a_f16_z_i32_rx$(OBJ) \ + test_a_f16_z_i64_rx$(OBJ) \ + test_a_f16_z_ui32_x$(OBJ) \ + test_a_f16_z_ui64_x$(OBJ) \ + test_a_f16_z_i32_x$(OBJ) \ + test_a_f16_z_i64_x$(OBJ) \ + test_a_f16_z_f32$(OBJ) \ + test_a_f16_z_f64$(OBJ) \ + test_a_f16_z_extF80$(OBJ) \ + test_a_f16_z_f128$(OBJ) \ + test_az_f16$(OBJ) \ + test_az_f16_rx$(OBJ) \ + test_abz_f16$(OBJ) \ + test_abcz_f16$(OBJ) \ + test_ab_f16_z_bool$(OBJ) \ + test_a_f32_z_ui32_rx$(OBJ) \ + test_a_f32_z_ui64_rx$(OBJ) \ + test_a_f32_z_i32_rx$(OBJ) \ + test_a_f32_z_i64_rx$(OBJ) \ + test_a_f32_z_ui32_x$(OBJ) \ + test_a_f32_z_ui64_x$(OBJ) \ + test_a_f32_z_i32_x$(OBJ) \ + test_a_f32_z_i64_x$(OBJ) \ + test_a_f32_z_f16$(OBJ) \ + test_a_f32_z_f64$(OBJ) \ + test_a_f32_z_extF80$(OBJ) \ + test_a_f32_z_f128$(OBJ) \ + test_az_f32$(OBJ) \ + test_az_f32_rx$(OBJ) \ + test_abz_f32$(OBJ) \ + test_abcz_f32$(OBJ) \ + test_ab_f32_z_bool$(OBJ) \ + test_a_f64_z_ui32_rx$(OBJ) \ + test_a_f64_z_ui64_rx$(OBJ) \ + test_a_f64_z_i32_rx$(OBJ) \ + test_a_f64_z_i64_rx$(OBJ) \ + test_a_f64_z_ui32_x$(OBJ) \ + test_a_f64_z_ui64_x$(OBJ) \ + test_a_f64_z_i32_x$(OBJ) \ + test_a_f64_z_i64_x$(OBJ) \ + test_a_f64_z_f16$(OBJ) \ + test_a_f64_z_f32$(OBJ) \ + test_a_f64_z_extF80$(OBJ) \ + test_a_f64_z_f128$(OBJ) \ + test_az_f64$(OBJ) \ + test_az_f64_rx$(OBJ) \ + test_abz_f64$(OBJ) \ + test_abcz_f64$(OBJ) \ + test_ab_f64_z_bool$(OBJ) \ + test_a_extF80_z_ui32_rx$(OBJ) \ + test_a_extF80_z_ui64_rx$(OBJ) \ + test_a_extF80_z_i32_rx$(OBJ) \ + test_a_extF80_z_i64_rx$(OBJ) \ + test_a_extF80_z_ui32_x$(OBJ) \ + test_a_extF80_z_ui64_x$(OBJ) \ + test_a_extF80_z_i32_x$(OBJ) \ + test_a_extF80_z_i64_x$(OBJ) \ + test_a_extF80_z_f16$(OBJ) \ + test_a_extF80_z_f32$(OBJ) \ + test_a_extF80_z_f64$(OBJ) \ + test_a_extF80_z_f128$(OBJ) \ + test_az_extF80$(OBJ) \ + test_az_extF80_rx$(OBJ) \ + test_abz_extF80$(OBJ) \ + test_ab_extF80_z_bool$(OBJ) \ + test_a_f128_z_ui32_rx$(OBJ) \ + test_a_f128_z_ui64_rx$(OBJ) \ + test_a_f128_z_i32_rx$(OBJ) \ + test_a_f128_z_i64_rx$(OBJ) \ + test_a_f128_z_ui32_x$(OBJ) \ + test_a_f128_z_ui64_x$(OBJ) \ + test_a_f128_z_i32_x$(OBJ) \ + test_a_f128_z_i64_x$(OBJ) \ + test_a_f128_z_f16$(OBJ) \ + test_a_f128_z_f32$(OBJ) \ + test_a_f128_z_f64$(OBJ) \ + test_a_f128_z_extF80$(OBJ) \ + test_az_f128$(OBJ) \ + test_az_f128_rx$(OBJ) \ + test_abz_f128$(OBJ) \ + test_abcz_f128$(OBJ) \ + test_ab_f128_z_bool$(OBJ) \ + +OBJS_LIB = \ + uint128_inline$(OBJ) \ + uint128$(OBJ) \ + fail$(OBJ) \ + functions_common$(OBJ) \ + functionInfos$(OBJ) \ + standardFunctionInfos$(OBJ) \ + random$(OBJ) \ + genCases_common$(OBJ) \ + $(OBJS_GENCASES) \ + genCases_writeTestsTotal$(OBJ) \ + verCases_inline$(OBJ) \ + verCases_common$(OBJ) \ + verCases_writeFunctionName$(OBJ) \ + readHex$(OBJ) \ + writeHex$(OBJ) \ + $(OBJS_WRITECASE) \ + testLoops_common$(OBJ) \ + $(OBJS_TEST) \ + +uint128$(OBJ): $(SOURCE_DIR)/uint128.h +fail$(OBJ): $(SOURCE_DIR)/fail.h +functions_common$(OBJ): $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h +functionInfos$(OBJ): $(SOURCE_DIR)/functions.h +standardFunctionInfos$(OBJ): $(SOURCE_DIR)/functions.h +random$(OBJ): $(SOURCE_DIR)/random.h +genCases_common$(OBJ): $(SOURCE_DIR)/fail.h $(SOURCE_DIR)/genCases.h +$(OBJS_GENCASES): \ + $(SOURCE_DIR)/random.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h +genCases_f128$(OBJ): $(SOURCE_DIR)/uint128.h +genCases_writeTestsTotal$(OBJ): $(SOURCE_DIR)/genCases.h +verCases_common$(OBJ): $(SOURCE_DIR)/verCases.h +verCases_writeFunctionName$(OBJ): $(SOURCE_DIR)/verCases.h +readHex$(OBJ): $(SOURCE_DIR)/readHex.h +writeHex$(OBJ): $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h +$(OBJS_WRITECASE): \ + $(SOFTFLOAT_H) $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/writeCase.h +testLoops_common$(OBJ): $(SOURCE_DIR)/testLoops.h +$(OBJS_TEST): \ + $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) $(SOURCE_DIR)/genCases.h \ + $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/testLoops.h +$(OBJS_LIB): %$(OBJ): platform.h $(SOURCE_DIR)/%.c + $(COMPILE_C) $(SOURCE_DIR)/$*.c +testfloat$(LIB): $(OBJS_LIB) + $(MAKELIB) $^ + +OBJS_TESTSOFTFLOAT = slowfloat$(OBJ) testsoftfloat$(OBJ) + +slowfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/slowfloat.c + $(COMPILE_SLOWFLOAT_C) $(SOURCE_DIR)/slowfloat.c +testsoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/slowfloat.h $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testsoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testsoftfloat.c + +testsoftfloat$(EXE): $(OBJS_TESTSOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TIMESOFTFLOAT = timesoftfloat$(OBJ) + +timesoftfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/timesoftfloat.c + $(COMPILE_C) $(SOURCE_DIR)/timesoftfloat.c + +timesoftfloat$(EXE): $(OBJS_TIMESOFTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_GEN = genLoops$(OBJ) testfloat_gen$(OBJ) + +genLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/writeHex.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/genLoops.c + $(COMPILE_C) $(SOURCE_DIR)/genLoops.c +testfloat_gen$(OBJ): \ + $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) $(SOURCE_DIR)/functions.h \ + $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/genLoops.h \ + $(SOURCE_DIR)/testfloat_gen.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_gen.c + +testfloat_gen$(EXE): $(OBJS_TESTFLOAT_GEN) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT_VER = verLoops$(OBJ) testfloat_ver$(OBJ) + +verLoops$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/readHex.h $(SOURCE_DIR)/verCases.h $(SOURCE_DIR)/writeCase.h \ + $(SOURCE_DIR)/verLoops.h $(SOURCE_DIR)/verLoops.c + $(COMPILE_C) $(SOURCE_DIR)/verLoops.c +testfloat_ver$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/writeCase.h $(SOURCE_DIR)/verLoops.h \ + $(SOURCE_DIR)/testfloat_ver.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat_ver.c + +testfloat_ver$(EXE): $(OBJS_TESTFLOAT_VER) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +OBJS_TESTFLOAT = subjfloat$(OBJ) subjfloat_functions$(OBJ) testfloat$(OBJ) + +subjfloat$(OBJ): \ + platform.h $(SOFTFLOAT_H) $(SUBJ_SOURCE_DIR)/subjfloat_config.h \ + $(SOURCE_DIR)/subjfloat.h $(SUBJ_SOURCE_DIR)/subjfloat.c + $(COMPILE_C) $(SUBJ_SOURCE_DIR)/subjfloat.c +subjfloat_functions$(OBJ): \ + platform.h $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/subjfloat_functions.c + $(COMPILE_C) $(SOURCE_DIR)/subjfloat_functions.c +testfloat$(OBJ): \ + platform.h $(SOURCE_DIR)/uint128.h $(SOURCE_DIR)/fail.h $(SOFTFLOAT_H) \ + $(SUBJ_SOURCE_DIR)/subjfloat_config.h $(SOURCE_DIR)/subjfloat.h \ + $(SOURCE_DIR)/functions.h $(SOURCE_DIR)/genCases.h $(SOURCE_DIR)/verCases.h \ + $(SOURCE_DIR)/testLoops.h $(SOURCE_DIR)/testfloat.c + $(COMPILE_C) $(SOURCE_DIR)/testfloat.c + +testfloat$(EXE): $(OBJS_TESTFLOAT) testfloat$(LIB) $(SOFTFLOAT_LIB) + $(LINK) $^ $(OTHER_LIBS) + +.PHONY: clean +clean: + $(DELETE) $(OBJS_LIB) testfloat$(LIB) + $(DELETE) $(OBJS_TESTSOFTFLOAT) testsoftfloat$(EXE) + $(DELETE) $(OBJS_TIMESOFTFLOAT) timesoftfloat$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_GEN) testfloat_gen$(EXE) + $(DELETE) $(OBJS_TESTFLOAT_VER) testfloat_ver$(EXE) + $(DELETE) $(OBJS_TESTFLOAT) testfloat$(EXE) + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/build/template/platform.h b/wally-pipelined/testbench/fp/TestFloat-3e/build/template/platform.h new file mode 100644 index 000000000..29cb8cc0c --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/build/template/platform.h @@ -0,0 +1,51 @@ + +/*============================================================================ + +This C header template is part of TestFloat, Release 3e, a package of programs +for testing the correctness of floating-point arithmetic complying with the +IEEE Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +// Edit lines marked with `==>'. See "TestFloat-source.html". + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define LITTLEENDIAN 1 + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define INLINE inline + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +==> #define THREAD_LOCAL _Thread_local + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-general.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-general.html new file mode 100644 index 000000000..730edc4be --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-general.html @@ -0,0 +1,1148 @@ + + + + +Berkeley TestFloat General Documentation + + + + +

Berkeley TestFloat Release 3e: General Documentation

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Contents

+ +
+ +++ + + + + + + + + + + + + + + + + + + + +
1. Introduction
2. Limitations
3. Acknowledgments and License
4. What TestFloat Does
5. Executing TestFloat
6. Operations Tested by TestFloat
6.1. Conversion Operations
6.2. Basic Arithmetic Operations
6.3. Fused Multiply-Add Operations
6.4. Remainder Operations
6.5. Round-to-Integer Operations
6.6. Comparison Operations
7. Interpreting TestFloat Output
8. Variations Allowed by the IEEE Floating-Point Standard
8.1. Underflow
8.2. NaNs
8.3. Conversions to Integer
9. Contact Information
+
+ + +

1. Introduction

+ +

+Berkeley TestFloat is a small collection of programs for testing that an +implementation of binary floating-point conforms to the IEEE Standard for +Floating-Point Arithmetic. +All operations required by the original 1985 version of the IEEE Floating-Point +Standard can be tested, except for conversions to and from decimal. +With the current release, the following binary formats can be tested: +16-bit half-precision, 32-bit single-precision, +64-bit double-precision, 80-bit +double-extended-precision, and/or 128-bit quadruple-precision. +TestFloat cannot test decimal floating-point. +

+ +

+Included in the TestFloat package are the testsoftfloat and +timesoftfloat programs for testing the Berkeley SoftFloat software +implementation of floating-point and for measuring its speed. +Information about SoftFloat can be found at the SoftFloat Web page, +http://www.jhauser.us/arithmetic/SoftFloat.html. +The testsoftfloat and timesoftfloat programs are +expected to be of interest only to people compiling the SoftFloat sources. +

+ +

+This document explains how to use the TestFloat programs. +It does not attempt to define or explain much of the IEEE Floating-Point +Standard. +Details about the standard are available elsewhere. +

+ +

+The current version of TestFloat is Release 3e. +This version differs from earlier releases 3b through 3d in only minor ways. +Compared to the original Release 3: +

    +
  • +Release 3b added the ability to test the 16-bit +half-precision format. +
  • +Release 3c added the ability to test a rarely used rounding mode, +round to odd, also known as jamming. +
  • +Release 3d modified the code for testing C arithmetic to +potentially include testing newer library functions sqrtf, +sqrtl, fmaf, fma, and fmal. +
+This release adds a few more small improvements, including modifying the +expected behavior of rounding mode odd and fixing a minor bug in +the all-in-one testfloat program. +

+ +

+Compared to Release 2c and earlier, the set of TestFloat programs, as well as +the programs’ arguments and behavior, changed some with +Release 3. +For more about the evolution of TestFloat releases, see +TestFloat-history.html. +

+ + +

2. Limitations

+ +

+TestFloat output is not always easily interpreted. +Detailed knowledge of the IEEE Floating-Point Standard and its vagaries is +needed to use TestFloat responsibly. +

+ +

+TestFloat performs relatively simple tests designed to check the fundamental +soundness of the floating-point under test. +TestFloat may also at times manage to find rarer and more subtle bugs, but it +will probably only find such bugs by chance. +Software that purposefully seeks out various kinds of subtle floating-point +bugs can be found through links posted on the TestFloat Web page, +http://www.jhauser.us/arithmetic/TestFloat.html. +

+ + +

3. Acknowledgments and License

+ +

+The TestFloat package was written by me, John R. Hauser. +Release 3 of TestFloat was a completely new implementation +supplanting earlier releases. +The project to create Release 3 (now through 3e) was +done in the employ of the University of California, Berkeley, within the +Department of Electrical Engineering and Computer Sciences, first for the +Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab. +The work was officially overseen by Prof. Krste Asanovic, with funding provided +by these sources: +

+ ++++ + + + + + + + + + +
Par Lab: +Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery +(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia, +NVIDIA, Oracle, and Samsung. +
ASPIRE Lab: +DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from +ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA, +Oracle, and Samsung. +
+
+

+ +

+The following applies to the whole of TestFloat Release 3e as well +as to each source file individually. +

+ +

+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. +All rights reserved. +

+ +

+Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +

    + +
  1. +

    +Redistributions of source code must retain the above copyright notice, this +list of conditions, and the following disclaimer. +

    + +
  2. +

    +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions, and the following disclaimer in the documentation and/or +other materials provided with the distribution. +

    + +
  3. +

    +Neither the name of the University nor the names of its contributors may be +used to endorse or promote products derived from this software without specific +prior written permission. +

    + +
+

+ +

+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS “AS IS”, +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. +IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +

+ + +

4. What TestFloat Does

+ +

+TestFloat is designed to test a floating-point implementation by comparing its +behavior with that of TestFloat’s own internal floating-point implemented +in software. +For each operation to be tested, the TestFloat programs can generate a large +number of test cases, made up of simple pattern tests intermixed with weighted +random inputs. +The cases generated should be adequate for testing carry chain propagations, +and the rounding of addition, subtraction, multiplication, and simple +operations like conversions. +TestFloat makes a point of checking all boundary cases of the arithmetic, +including underflows, overflows, invalid operations, subnormal inputs, zeros +(positive and negative), infinities, and NaNs. +For the interesting operations like addition and multiplication, millions of +test cases may be checked. +

+ +

+TestFloat is not remarkably good at testing difficult rounding cases for +division and square root. +It also makes no attempt to find bugs specific to SRT division and the like +(such as the infamous Pentium division bug). +Software that tests for such failures can be found through links on the +TestFloat Web page, +http://www.jhauser.us/arithmetic/TestFloat.html. +

+ +

+NOTE!
+It is the responsibility of the user to verify that the discrepancies TestFloat +finds actually represent faults in the implementation being tested. +Advice to help with this task is provided later in this document. +Furthermore, even if TestFloat finds no fault with a floating-point +implementation, that in no way guarantees that the implementation is bug-free. +

+ +

+For each operation, TestFloat can test all five rounding modes defined by the +IEEE Floating-Point Standard, plus possibly a sixth mode, round to odd +(depending on the options selected when TestFloat was built). +TestFloat verifies not only that the numeric results of an operation are +correct, but also that the proper floating-point exception flags are raised. +All five exception flags are tested, including the inexact flag. +TestFloat does not attempt to verify that the floating-point exception flags +are actually implemented as sticky flags. +

+ +

+For the 80-bit double-extended-precision format, TestFloat can +test the addition, subtraction, multiplication, division, and square root +operations at all three of the standard rounding precisions. +The rounding precision can be set to 32 bits, equivalent to +single-precision, to 64 bits, equivalent to double-precision, or +to the full 80 bits of the double-extended-precision. +Rounding precision control can be applied only to the double-extended-precision +format and only for the five basic arithmetic operations: addition, +subtraction, multiplication, division, and square root. +Other operations can be tested only at full precision. +

+ +

+As a rule, TestFloat is not particular about the bit patterns of NaNs that +appear as operation results. +Any NaN is considered as good a result as another. +This laxness can be overridden so that TestFloat checks for particular bit +patterns within NaN results. +See section 8 below, Variations Allowed by the IEEE +Floating-Point Standard, plus the -checkNaNs and +-checkInvInts options documented for programs +testfloat_ver and testfloat. +

+ +

+TestFloat normally compares an implementation of floating-point against the +Berkeley SoftFloat software implementation of floating-point, also created by +me. +The SoftFloat functions are linked into each TestFloat program’s +executable. +Information about SoftFloat can be found at the Web page +http://www.jhauser.us/arithmetic/SoftFloat.html. +

+ +

+For testing SoftFloat itself, the TestFloat package includes a +testsoftfloat program that compares SoftFloat’s +floating-point against another software floating-point implementation. +The second software floating-point is simpler and slower than SoftFloat, and is +completely independent of SoftFloat. +Although the second software floating-point cannot be guaranteed to be +bug-free, the chance that it would mimic any of SoftFloat’s bugs is low. +Consequently, an error in one or the other floating-point version should appear +as an unexpected difference between the two implementations. +Note that testing SoftFloat should be necessary only when compiling a new +TestFloat executable or when compiling SoftFloat for some other reason. +

+ + +

5. Executing TestFloat

+ +

+The TestFloat package consists of five programs, all intended to be executed +from a command-line interpreter: +

+ + + + + + + + + + + + + + + + + + + + + +
+testfloat_gen    + +Generates test cases for a specific floating-point operation. +
+testfloat_ver + +Verifies whether the results from executing a floating-point operation are as +expected. +
+testfloat + +An all-in-one program that generates test cases, executes floating-point +operations, and verifies whether the results match expectations. +
+testsoftfloat    + +Like testfloat, but for testing SoftFloat. +
+timesoftfloat    + +A program for measuring the speed of SoftFloat (included in the TestFloat +package for convenience). +
+
+Each program has its own page of documentation that can be opened through the +links in the table above. +

+ +

+To test a floating-point implementation other than SoftFloat, one of three +different methods can be used. +The first method pipes output from testfloat_gen to a program +that: +(a) reads the incoming test cases, (b) invokes the +floating-point operation being tested, and (c) writes the +operation results to output. +These results can then be piped to testfloat_ver to be checked for +correctness. +Assuming a vertical bar (|) indicates a pipe between programs, the +complete process could be written as a single command like so: +

+
+testfloat_gen ... <type> | <program-that-invokes-op> | testfloat_ver ... <function>
+
+
+The program in the middle is not supplied by TestFloat but must be created +independently. +If for some reason this program cannot take command-line arguments, the +-prefix option of testfloat_gen can communicate +parameters through the pipe. +

+ +

+A second method for running TestFloat is similar but has +testfloat_gen supply not only the test inputs but also the +expected results for each case. +With this additional information, the job done by testfloat_ver +can be folded into the invoking program to give the following command: +

+
+testfloat_gen ... <function> | <program-that-invokes-op-and-compares-results>
+
+
+Again, the program that actually invokes the floating-point operation is not +supplied by TestFloat but must be created independently. +Depending on circumstance, it may be preferable either to let +testfloat_ver check and report suspected errors (first method) or +to include this step in the invoking program (second method). +

+ +

+The third way to use TestFloat is the all-in-one testfloat +program. +This program can perform all the steps of creating test cases, invoking the +floating-point operation, checking the results, and reporting suspected errors. +However, for this to be possible, testfloat must be compiled to +contain the method for invoking the floating-point operations to test. +Each build of testfloat is therefore capable of testing +only the floating-point implementation it was built to invoke. +To test a new implementation of floating-point, a new testfloat +must be created, linked to that specific implementation. +By comparison, the testfloat_gen and testfloat_ver +programs are entirely generic; +one instance is usable for testing any floating-point implementation, because +implementation-specific details are segregated in the custom program that +follows testfloat_gen. +

+ +

+Program testsoftfloat is another all-in-one program specifically +for testing SoftFloat. +

+ +

+Programs testfloat_ver, testfloat, and +testsoftfloat all report status and error information in a common +way. +As it executes, each of these programs writes status information to the +standard error output, which should be the screen by default. +In order for this status to be displayed properly, the standard error stream +should not be redirected to a file. +Any discrepancies that are found are written to the standard output stream, +which is easily redirected to a file if desired. +Unless redirected, reported errors will appear intermixed with the ongoing +status information in the output. +

+ + +

6. Operations Tested by TestFloat

+ +

+TestFloat can test all operations required by the original 1985 IEEE +Floating-Point Standard except for conversions to and from decimal. +These operations are: +

    +
  • +conversions among the supported floating-point formats, and also between +integers (32-bit and 64-bit, signed and unsigned) and +any of the floating-point formats; +
  • +for each floating-point format, the usual addition, subtraction, +multiplication, division, and square root operations; +
  • +for each format, the floating-point remainder operation defined by the IEEE +Standard; +
  • +for each format, a “round to integer” operation that rounds to the +nearest integer value in the same format; and +
  • +comparisons between two values in the same floating-point format. +
+In addition, TestFloat can also test +
    +
  • +for each floating-point format except 80-bit +double-extended-precision, the fused multiply-add operation defined by the 2008 +IEEE Standard. +
+

+ +

+More information about all these operations is given below. +In the operation names used by TestFloat, 16-bit half-precision is +called f16, 32-bit single-precision is +f32, 64-bit double-precision is f64, +80-bit double-extended-precision is extF80, and +128-bit quadruple-precision is f128. +TestFloat generally uses the same names for operations as Berkeley SoftFloat, +except that TestFloat’s names never include the M that +SoftFloat uses to indicate that values are passed through pointers. +

+ +

6.1. Conversion Operations

+ +

+All conversions among the floating-point formats and all conversions between a +floating-point format and 32-bit and 64-bit integers +can be tested. +The conversion operations are: +

+
+ui32_to_f16      ui64_to_f16      i32_to_f16       i64_to_f16
+ui32_to_f32      ui64_to_f32      i32_to_f32       i64_to_f32
+ui32_to_f64      ui64_to_f64      i32_to_f64       i64_to_f64
+ui32_to_extF80   ui64_to_extF80   i32_to_extF80    i64_to_extF80
+ui32_to_f128     ui64_to_f128     i32_to_f128      i64_to_f128
+
+f16_to_ui32      f32_to_ui32      f64_to_ui32      extF80_to_ui32    f128_to_ui32
+f16_to_ui64      f32_to_ui64      f64_to_ui64      extF80_to_ui64    f128_to_ui64
+f16_to_i32       f32_to_i32       f64_to_i32       extF80_to_i32     f128_to_i32
+f16_to_i64       f32_to_i64       f64_to_i64       extF80_to_i64     f128_to_i64
+
+f16_to_f32       f32_to_f16       f64_to_f16       extF80_to_f16     f128_to_f16
+f16_to_f64       f32_to_f64       f64_to_f32       extF80_to_f32     f128_to_f32
+f16_to_extF80    f32_to_extF80    f64_to_extF80    extF80_to_f64     f128_to_f64
+f16_to_f128      f32_to_f128      f64_to_f128      extF80_to_f128    f128_to_extF80
+
+
+Abbreviations ui32 and ui64 indicate +32-bit and 64-bit unsigned integer types, while +i32 and i64 indicate their signed counterparts. +These conversions all round according to the current rounding mode as relevant. +Conversions from a smaller to a larger floating-point format are always exact +and so require no rounding. +Likewise, conversions from 32-bit integers to 64-bit +double-precision or to any larger floating-point format are also exact, as are +conversions from 64-bit integers to 80-bit +double-extended-precision and 128-bit quadruple-precision. +

+ +

+For the all-in-one testfloat program, this list of conversion +operations requires amendment. +For testfloat only, conversions to an integer type have names that +explicitly specify the rounding mode and treatment of inexactness. +Thus, instead of +

+
+<float>_to_<int>
+
+
+as listed above, operations converting to integer type have names of these +forms: +
+
+<float>_to_<int>_r_<round>
+<float>_to_<int>_rx_<round>
+
+
+The <round> component is one of +‘near_even’, ‘near_maxMag’, +‘minMag’, ‘min’, or +‘max’, choosing the rounding mode. +Any other indication of rounding mode is ignored. +The operations with ‘_r_’ in their names never raise +the inexact exception, while those with ‘_rx_’ +raise the inexact exception whenever the result is not exact. +

+ +

+TestFloat assumes that conversions from floating-point to an integer type +should raise the invalid exception if the input cannot be rounded to an +integer representable in the result format. +In such a circumstance: +

    + +
  • +

    +If the result type is an unsigned integer, TestFloat normally expects the +result of the operation to be the type’s largest integer value. +In the case that the input is a negative number (not a NaN), a zero result may +also be accepted. +

    + +
  • +

    +If the result type is a signed integer and the input is a number (not a NaN), +TestFloat expects the result to be the largest-magnitude integer with the same +sign as the input. +When a NaN is converted to a signed integer type, TestFloat allows either the +largest postive or largest-magnitude negative integer to be returned. +

    + +
+Conversions to integer types are expected never to raise the overflow +exception. +

+ +

6.2. Basic Arithmetic Operations

+ +

+The following standard arithmetic operations can be tested: +

+
+f16_add      f16_sub      f16_mul      f16_div      f16_sqrt
+f32_add      f32_sub      f32_mul      f32_div      f32_sqrt
+f64_add      f64_sub      f64_mul      f64_div      f64_sqrt
+extF80_add   extF80_sub   extF80_mul   extF80_div   extF80_sqrt
+f128_add     f128_sub     f128_mul     f128_div     f128_sqrt
+
+
+The double-extended-precision (extF80) operations can be rounded +to reduced precision under rounding precision control. +

+ +

6.3. Fused Multiply-Add Operations

+ +

+For all floating-point formats except 80-bit +double-extended-precision, TestFloat can test the fused multiply-add operation +defined by the 2008 IEEE Floating-Point Standard. +The fused multiply-add operations are: +

+
+f16_mulAdd
+f32_mulAdd
+f64_mulAdd
+f128_mulAdd
+
+
+

+ +

+If one of the multiplication operands is infinite and the other is zero, +TestFloat expects the fused multiply-add operation to raise the invalid +exception even if the third operand is a quiet NaN. +

+ +

6.4. Remainder Operations

+ +

+For each format, TestFloat can test the IEEE Standard’s remainder +operation. +These operations are: +

+
+f16_rem
+f32_rem
+f64_rem
+extF80_rem
+f128_rem
+
+
+The remainder operations are always exact and so require no rounding. +

+ +

6.5. Round-to-Integer Operations

+ +

+For each format, TestFloat can test the IEEE Standard’s round-to-integer +operation. +For most TestFloat programs, these operations are: +

+
+f16_roundToInt
+f32_roundToInt
+f64_roundToInt
+extF80_roundToInt
+f128_roundToInt
+
+
+

+ +

+Just as for conversions to integer types (section 6.1 above), the +all-in-one testfloat program is again an exception. +For testfloat only, the round-to-integer operations have names of +these forms: +

+
+<float>_roundToInt_r_<round>
+<float>_roundToInt_x
+
+
+For the ‘_r_’ versions, the inexact exception +is never raised, and the <round> component specifies +the rounding mode as one of ‘near_even’, +‘near_maxMag’, ‘minMag’, +‘min’, or ‘max’. +The usual indication of rounding mode is ignored. +In contrast, the ‘_x’ versions accept the usual +indication of rounding mode and raise the inexact exception whenever the +result is not exact. +This irregular system follows the IEEE Standard’s particular +specification for the round-to-integer operations. +

+ +

6.6. Comparison Operations

+ +

+The following floating-point comparison operations can be tested: +

+
+f16_eq      f16_le      f16_lt
+f32_eq      f32_le      f32_lt
+f64_eq      f64_le      f64_lt
+extF80_eq   extF80_le   extF80_lt
+f128_eq     f128_le     f128_lt
+
+
+The abbreviation eq stands for “equal” (=), +le stands for “less than or equal” (≤), and +lt stands for “less than” (<). +

+ +

+The IEEE Standard specifies that, by default, the less-than-or-equal and +less-than comparisons raise the invalid exception if either input is any +kind of NaN. +The equality comparisons, on the other hand, are defined by default to raise +the invalid exception only for signaling NaNs, not for quiet NaNs. +For completeness, the following additional operations can be tested if +supported: +

+
+f16_eq_signaling      f16_le_quiet      f16_lt_quiet
+f32_eq_signaling      f32_le_quiet      f32_lt_quiet
+f64_eq_signaling      f64_le_quiet      f64_lt_quiet
+extF80_eq_signaling   extF80_le_quiet   extF80_lt_quiet
+f128_eq_signaling     f128_le_quiet     f128_lt_quiet
+
+
+The signaling equality comparisons are identical to the standard +operations except that the invalid exception should be raised for any +NaN input. +Similarly, the quiet comparison operations should be identical to +their counterparts except that the invalid exception is not raised for +quiet NaNs. +

+ +

+Obviously, no comparison operations ever require rounding. +Any rounding mode is ignored. +

+ + +

7. Interpreting TestFloat Output

+ +

+The “errors” reported by TestFloat programs may or may not really +represent errors in the system being tested. +For each test case tried, the results from the floating-point implementation +being tested could differ from the expected results for several reasons: +

    +
  • +The IEEE Floating-Point Standard allows for some variation in how conforming +floating-point behaves. +Two implementations can sometimes give different results without either being +incorrect. +
  • +The trusted floating-point emulation could be faulty. +This could be because there is a bug in the way the emulation is coded, or +because a mistake was made when the code was compiled for the current system. +
  • +The TestFloat program may not work properly, reporting differences that do not +exist. +
  • +Lastly, the floating-point being tested could actually be faulty. +
+It is the responsibility of the user to determine the causes for the +discrepancies that are reported. +Making this determination can require detailed knowledge about the IEEE +Standard. +Assuming TestFloat is working properly, any differences found will be due to +either the first or last of the reasons above. +Variations in the IEEE Standard that could lead to false error reports are +discussed in section 8, Variations Allowed by the IEEE +Floating-Point Standard. +

+ +

+For each reported error (or apparent error), a line of text is written to the +default output. +If a line would be longer than 79 characters, it is divided. +The first part of each error line begins in the leftmost column, and any +subsequent “continuation” lines are indented with a tab. +

+ +

+Each error reported is of the form: +

+
+<inputs>  => <observed-output>  expected: <expected-output>
+
+
+The <inputs> are the inputs to the operation. +Each output (observed or expected) is shown as a pair: the result value first, +followed by the exception flags. +

+ +

+For example, two typical error lines could be +

+
+-00.7FFF00  -7F.000100  => +01.000000 ...ux  expected: +01.000000 ....x
++81.000004  +00.1FFFFF  => +01.000000 ...ux  expected: +01.000000 ....x
+
+
+In the first line, the inputs are -00.7FFF00 and +-7F.000100, and the observed result is +01.000000 +with flags ...ux. +The trusted emulation result is the same but with different flags, +....x. +Items such as -00.7FFF00 composed of a sign character +(+/-), hexadecimal digits, and a single +period represent floating-point values (here 32-bit +single-precision). +The two instances above were reported as errors because the exception flag +results differ. +

+ +

+Aside from the exception flags, there are ten data types that may be +represented. +Five are floating-point types: 16-bit half-precision, +32-bit single-precision, 64-bit double-precision, +80-bit double-extended-precision, and 128-bit +quadruple-precision. +The remaining five types are 32-bit and 64-bit +unsigned integers, 32-bit and 64-bit +two’s-complement signed integers, and Boolean values (the results of +comparison operations). +Boolean values are represented as a single character, either a 0 +(false) or a 1 (true). +A 32-bit integer is represented as 8 hexadecimal digits. +Thus, for a signed 32-bit integer, FFFFFFFF is +−1, and 7FFFFFFF is the largest positive value. +64-bit integers are the same except with 16 hexadecimal digits. +

+ +

+Floating-point values are written decomposed into their sign, encoded exponent, +and encoded significand. +First is the sign character (+ or -), +followed by the encoded exponent in hexadecimal, then a period +(.), and lastly the encoded significand in hexadecimal. +

+ +

+For 16-bit half-precision, notable values include: +

+ + + + + + + + + + + + + + + +
+00.000    +0
+0F.000 1
+10.000 2
+1E.3FFmaximum finite value
+1F.000+infinity
 
-00.000−0
-0F.000−1
-10.000−2
-1E.3FFminimum finite value (largest magnitude, but negative)
-1F.000−infinity
+
+Certain categories are easily distinguished (assuming the xs are +not all 0): +
+ + + + + + + + +
+00.xxx    positive subnormal numbers
+1F.xxxpositive NaNs
-00.xxxnegative subnormal numbers
-1F.xxxnegative NaNs
+
+

+ +

+Likewise for other formats: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
32-bit single64-bit double128-bit quadruple
 
+00.000000    +000.0000000000000    +0000.0000000000000000000000000000    +0
+7F.000000+3FF.0000000000000+3FFF.0000000000000000000000000000 1
+80.000000+400.0000000000000+4000.0000000000000000000000000000 2
+FE.7FFFFF+7FE.FFFFFFFFFFFFF+7FFE.FFFFFFFFFFFFFFFFFFFFFFFFFFFFmaximum finite value
+FF.000000+7FF.0000000000000+7FFF.0000000000000000000000000000+infinity
 
-00.000000    -000.0000000000000    -0000.0000000000000000000000000000    −0
-7F.000000-3FF.0000000000000-3FFF.0000000000000000000000000000−1
-80.000000-400.0000000000000-4000.0000000000000000000000000000−2
-FE.7FFFFF-7FE.FFFFFFFFFFFFF-7FFE.FFFFFFFFFFFFFFFFFFFFFFFFFFFFminimum finite value
-FF.000000-7FF.0000000000000-7FFF.0000000000000000000000000000−infinity
 
+00.xxxxxx+000.xxxxxxxxxxxxx+0000.xxxxxxxxxxxxxxxxxxxxxxxxxxxxpositive subnormals
+FF.xxxxxx+7FF.xxxxxxxxxxxxx+7FFF.xxxxxxxxxxxxxxxxxxxxxxxxxxxxpositive NaNs
-00.xxxxxx-000.xxxxxxxxxxxxx-0000.xxxxxxxxxxxxxxxxxxxxxxxxxxxxnegative subnormals
-FF.xxxxxx-7FF.xxxxxxxxxxxxx-7FFF.xxxxxxxxxxxxxxxxxxxxxxxxxxxxnegative NaNs
+
+

+ +

+The 80-bit double-extended-precision values are a little unusual +in that the leading bit of precision is not hidden as with other formats. +When canonically encoded, the leading significand bit of an 80-bit +double-extended-precision value will be 0 if the value is zero or subnormal, +and will be 1 otherwise. +Hence, the same values listed above appear in 80-bit +double-extended-precision as follows (note the leading 8 digit in +the significands): +

+ + + + + + + + + + + + + + + + + + + + + +
+0000.0000000000000000    +0
+3FFF.8000000000000000 1
+4000.8000000000000000 2
+7FFE.FFFFFFFFFFFFFFFFmaximum finite value
+7FFF.8000000000000000+infinity
 
-0000.0000000000000000−0
-3FFF.8000000000000000−1
-4000.8000000000000000−2
-7FFE.FFFFFFFFFFFFFFFFminimum finite value
-7FFF.8000000000000000−infinity
+
+

+ +

+Lastly, exception flag values are represented by five characters, one character +per flag. +Each flag is written as either a letter or a period (.) according +to whether the flag was set or not by the operation. +A period indicates the flag was not set. +The letter used to indicate a set flag depends on the flag: +

+ + + + + + + + + + + + +
v    invalid exception
iinfinite exception (“divide by zero”)
ooverflow exception
uunderflow exception
xinexact exception
+
+For example, the notation ...ux indicates that the +underflow and inexact exception flags were set and that the other +three flags (invalid, infinite, and overflow) were not +set. +The exception flags are always written following the value returned as the +result of the operation. +

+ + +

8. Variations Allowed by the IEEE Floating-Point Standard

+ +

+The IEEE Floating-Point Standard admits some variation among conforming +implementations. +Because TestFloat expects the two implementations being compared to deliver +bit-for-bit identical results under most circumstances, this leeway in the +standard can result in false errors being reported if the two implementations +do not make the same choices everywhere the standard provides an option. +

+ +

8.1. Underflow

+ +

+The standard specifies that the underflow exception flag is to be raised +when two conditions are met simultaneously: +(1) tininess and (2) loss of accuracy. +

+ +

+A result is tiny when its magnitude is nonzero yet smaller than any normalized +floating-point number. +The standard allows tininess to be determined either before or after a result +is rounded to the destination precision. +If tininess is detected before rounding, some borderline cases will be flagged +as underflows even though the result after rounding actually lies within the +normal floating-point range. +By detecting tininess after rounding, a system can avoid some unnecessary +signaling of underflow. +All the TestFloat programs support options -tininessbefore and +-tininessafter to control whether TestFloat expects tininess on +underflow to be detected before or after rounding. +One or the other is selected as the default when TestFloat is compiled, but +these command options allow the default to be overridden. +

+ +

+Loss of accuracy occurs when the subnormal format is not sufficient to +represent an underflowed result accurately. +The original 1985 version of the IEEE Standard allowed loss of accuracy to be +detected either as an inexact result or as a +denormalization loss; +however, few if any systems ever chose the latter. +The latest standard requires that loss of accuracy be detected as an inexact +result, and TestFloat can test only for this case. +

+ +

8.2. NaNs

+ +

+The IEEE Standard gives the floating-point formats a large number of NaN +encodings and specifies that NaNs are to be returned as results under certain +conditions. +However, the standard allows an implementation almost complete freedom over +which NaN to return in each situation. +

+ +

+By default, TestFloat does not check the bit patterns of NaN results. +When the result of an operation should be a NaN, any NaN is considered as good +as another. +This laxness can be overridden with the -checkNaNs option of +programs testfloat_ver and testfloat. +In order for this option to be sensible, TestFloat must have been compiled so +that its internal floating-point implementation (SoftFloat) generates the +proper NaN results for the system being tested. +

+ +

8.3. Conversions to Integer

+ +

+Conversion of a floating-point value to an integer format will fail if the +source value is a NaN or if it is too large. +The IEEE Standard does not specify what value should be returned as the integer +result in these cases. +Moreover, according to the standard, the invalid exception can be raised +or an unspecified alternative mechanism may be used to signal such cases. +

+ +

+TestFloat assumes that conversions to integer will raise the invalid +exception if the source value cannot be rounded to a representable integer. +In such cases, TestFloat expects the result value to be the largest-magnitude +positive or negative integer or zero, as detailed earlier in +section 6.1, Conversion Operations. +If option -checkInvInts is selected with programs +testfloat_ver and testfloat, integer results of +invalid operations are checked for an exact match. +In order for this option to be sensible, TestFloat must have been compiled so +that its internal floating-point implementation (SoftFloat) generates the +proper integer results for the system being tested. +

+ + +

9. Contact Information

+ +

+At the time of this writing, the most up-to-date information about TestFloat +and the latest release can be found at the Web page +http://www.jhauser.us/arithmetic/TestFloat.html. +

+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-history.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-history.html new file mode 100644 index 000000000..8de782cad --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-history.html @@ -0,0 +1,272 @@ + + + + +Berkeley TestFloat History + + + + +

History of Berkeley TestFloat, to Release 3e

+ +

+John R. Hauser
+2018 January 20
+

+ + +

+Releases of Berkeley TestFloat normally parallel those of Berkeley SoftFloat, +on which TestFloat is based. +Each TestFloat release necessarily incorporates all bug fixes from the +corresponding release of SoftFloat. +

+ + +

Release 3e (2018 January)

+ +
    + +
  • +Fixed a problem with the all-in-one testfloat program whereby +function set -all1 incorrectly also tested the three-operand fused +multiply-add operations. + +
  • +Modified the expected behavior of rounding mode odd (jamming) when +rounding to an integer value (either conversion to an integer format or a +‘roundToInt’ function). +Previously, for those cases only, rounding mode odd was expected +to act the same as rounding to minimum magnitude. +Now, when rounding to an integer value, the nearest odd integer is expected, +consistent with the round-to-odd result of other operations. + +
  • +Added options -checkInvInts and -checkAll to programs +testfloat_ver and testfloat. + +
  • +Improved the checking of integer results of invalid operations. + +
+ + +

Release 3d (2017 August)

+ +
    + +
  • +When the all-in-one testfloat program is compiled to test the C +language’s arithmetic, added the ability to test library functions +sqrtf, sqrtl, fmaf, fma, +and fmal, which were added to the C Standard in 1999. + +
+ + +

Release 3c (2017 February)

+ +
    + +
  • +Added support for testing rounding mode odd (jamming). + +
  • +Made support for testing 64-bit double-precistion floating-point +be subject to macro FLOAT64 (akin to macros FLOAT16, +EXTFLOAT80, and FLOAT128 from before). + +
  • +Fixed some bugs that caused compilation to fail with certain combinations of +option macro settings. + +
  • +Corrected the types of two internal variables to be sig_atomic_t +instead of bool. + +
  • +Improved the formatting of some error reports (concerning where lines are +broken when they exceed 79 characters in length). + +
+ + +

Release 3b (2016 July)

+ +
    + +
  • +Added the ability to test the common 16-bit +“half-precision” floating-point format. + +
  • +Added a -seed option to programs testfloat_gen, +testfloat, and testsoftfloat for setting the seed for +the pseudo-random number generator used to generate test cases. + +
  • +Where a specific choice is needed for how tininess is detected on underflow, +changed the default to be the detection of tininess after rounding +(-tininessafter) instead of before rounding +(-tininessbefore). + +
  • +Modified the format of reported discrepancies to show the signs of +floating-point values using + and - characters. + +
  • +Documented the use of the INLINE macro, and fixed the sources for +the case that function inlining is not supported by the C compiler. + +
  • +Documented the possible need to define macro THREAD_LOCAL to match +how the SoftFloat library was built. + +
  • +Modified the provided Makefiles to allow some options to be overridden from the +make command. + +
+ + +

Release 3a (2015 October)

+ +
    + +
  • +Replaced the license text supplied by the University of California, Berkeley, +and fixed some minor build problems. + +
+ + +

Release 3 (2015 February)

+ +
    + +
  • +Complete rewrite, funded by the University of California, Berkeley, and +consequently having a different use license than earlier releases. +Visible changes included different names for testable functions and command +options. + +
  • +Reinstated separate programs for generating test cases +(testfloat_ver) and verifying test results +(testfloat_gen), as alternatives to the all-in-one +testfloat program (which remained supported). + +
  • +Added support for testing conversions between floating-point and unsigned +integers, both 32-bit and 64-bit. + +
  • +Added support for testing a fused multiply-add operation, for all testable +floating-point formats except 80-bit double-extended-precision. + +
  • +Added support for testing a fifth rounding mode, near_maxMag +(round to nearest, with ties to maximum magnitude, away from zero). + +
  • +Added timesoftfloat (previously found in the Berkeley SoftFloat +package). + +
+ + +

Release 2c (2015 January)

+ +
    + +
  • +Fixed mistakes affecting some 64-bit processors. + +
  • +Made minor updates to the documentation, including improved wording for the +legal restrictions on using TestFloat releases through 2c (not +applicable to Release 3 or later). + +
+ + +

+There was never a Release 2b. +

+ + +

Release 2a (1998 December)

+ +
    + +
  • +Added support for testing conversions between floating-point and +64-bit signed integers. + +
  • +Improved the Makefiles. + +
+ + +

Release 2 (1997 June)

+ +
    + +
  • +Integrated the generation of test cases and the checking of system results into +a single program. +(Before they were separate programs, normally joined by explicit command-line +pipes.) + +
  • +Improved the sequence of test cases. + +
  • +Added support for testing 80-bit double-extended-precision and +128-bit quadruple precision. + +
  • +Made program output more readable, and added new command arguments. + +
  • +Reduced dependence on the quality of the standard rand function +for generating test cases. +(Previously naively expected rand to be able to generate good +random bits for the entire machine word width.) + +
  • +Created testsoftfloat, with its own simpler complete software +floating-point (“slowfloat”) for comparison purposes. + +
  • +Made some changes to the source file structure, including renaming +environment.h to milieu.h (to avoid confusion with +environment variables). + +
+ + +

Release 1a (1996 July)

+ +
    + +
  • +Added the -tininessbefore and -tininessafter options +to control whether tininess should be detected before or after rounding. + +
+ + +

Release 1 (1996 July)

+ +
    + +
  • +Original release. + +
+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-source.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-source.html new file mode 100644 index 000000000..ec3a4b47d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/TestFloat-source.html @@ -0,0 +1,639 @@ + + + + +Berkeley TestFloat Source Documentation + + + + +

Berkeley TestFloat Release 3e: Source Documentation

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Contents

+ +
+ +++ + + + + + + + + + + + + + + +
1. Introduction
2. Limitations
3. Acknowledgments and License
4. TestFloat Package Directory Structure
5. Dependence on Berkeley SoftFloat
6. Issues for Porting TestFloat to a New Target
6.1. Standard Headers <stdbool.h> and + <stdint.h>
6.2. Standard Header <fenv.h>
6.3. Macros for Build Options
6.4. Specializing the testfloat Program
6.5. Improving the Random Number Functions
7. Contact Information
+
+ + +

1. Introduction

+ +

+This document gives information needed for compiling and/or porting Berkeley +TestFloat, a small collection of programs for testing that an implementation of +binary floating-point conforms to the IEEE Standard for Floating-Point +Arithmetic. +For basic documentation about TestFloat refer to +TestFloat-general.html. +

+ +

+The source code for TestFloat is intended to be relatively machine-independent. +Most programs in the TestFloat package should be compilable with any +ISO-Standard C compiler that also supports 64-bit integers. +If the all-in-one testfloat program will be used to test a new +floating-point implementation, additional effort will likely be required to +retarget that program to invoke the new floating-point operations. +TestFloat has been successfully compiled with the GNU C Compiler +(gcc) for several platforms. +

+ +

+Release 3 of TestFloat was a complete rewrite relative to +Release 2c or earlier. +The current version of TestFloat is Release 3e. +

+ +

+TestFloat depends on Berkeley SoftFloat, which is a software implementation of +binary floating-point that conforms to the IEEE Standard for Floating-Point +Arithmetic. +SoftFloat is not included with the TestFloat sources. +It can be obtained from the Web page +http://www.jhauser.us/arithmetic/SoftFloat.html. +

+ + +

2. Limitations

+ +

+TestFloat assumes the computer has an addressable byte size of either 8 or +16 bits. +(Nearly all computers in use today have 8-bit bytes.) +

+ +

+TestFloat is written entirely in C. +The C compiler used must conform at a minimum to the 1989 ANSI standard for the +C language (same as the 1990 ISO standard) and must in addition support basic +arithmetic on 64-bit integers. +Earlier releases of TestFloat were capable of testing 32-bit +single-precision and 64-bit double-precision floating-point +without requiring compiler support for 64-bit integers, but this +option is not supported starting with Release 3. +Since 1999, ISO standards for C have mandated compiler support for +64-bit integers. +A compiler conforming to the 1999 C Standard or later is recommended but not +strictly required. +

+ +

+C Standard header files <stdbool.h> and +<stdint.h> are required for defining standard Boolean and +integer types. +If these headers are not supplied with the C compiler, minimal substitutes must +be provided. +TestFloat’s dependence on these headers is detailed later in +section 6.1, Standard Headers <stdbool.h> +and <stdint.h>. +

+ + +

3. Acknowledgments and License

+ +

+The TestFloat package was written by me, John R. Hauser. +Release 3 of TestFloat was a completely new implementation +supplanting earlier releases. +The project to create Release 3 (now through 3e) was +done in the employ of the University of California, Berkeley, within the +Department of Electrical Engineering and Computer Sciences, first for the +Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab. +The work was officially overseen by Prof. Krste Asanovic, with funding provided +by these sources: +

+ ++++ + + + + + + + + + +
Par Lab: +Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery +(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia, +NVIDIA, Oracle, and Samsung. +
ASPIRE Lab: +DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from +ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA, +Oracle, and Samsung. +
+
+

+ +

+The following applies to the whole of TestFloat Release 3e as well +as to each source file individually. +

+ +

+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. +All rights reserved. +

+ +

+Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: +

    + +
  1. +

    +Redistributions of source code must retain the above copyright notice, this +list of conditions, and the following disclaimer. +

    + +
  2. +

    +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions, and the following disclaimer in the documentation and/or +other materials provided with the distribution. +

    + +
  3. +

    +Neither the name of the University nor the names of its contributors may be +used to endorse or promote products derived from this software without specific +prior written permission. +

    + +
+

+ +

+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS “AS IS”, +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. +IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +

+ + +

4. TestFloat Package Directory Structure

+ +

+Because TestFloat is targeted to multiple platforms, its source code is +slightly scattered between target-specific and target-independent directories +and files. +The supplied directory structure is as follows: +

+
+doc
+source
+    subj-C
+build
+    template
+    Linux-386-GCC
+    Linux-386-SSE2-GCC
+    Linux-x86_64-GCC
+    Linux-ARM-VFPv2-GCC
+    Win32-MinGW
+    Win32-SSE2-MinGW
+    Win64-MinGW-w64
+
+
+The majority of the TestFloat sources are provided in the source +directory. +The subj-C subdirectory contains the sources that +configure the all-in-one testfloat program to test the C +compiler’s implementation of the standard C types float, +double, and possibly long double. +The ‘subj’ in subj-C is an +abbreviation of subject, referring to the floating-point that is the +subject of the test. +If testfloat is retargeted to test other floating-point +implementations, the corresponding source files would be expected to be in +other subdirectories alongside subj-C, with names of +the form subj-<target>. +More about retargeting testfloat is found in +section 6.4, Specializing the testfloat +Program. +

+ +

+The build directory is intended to contain a subdirectory for each +target platform for which builds of the TestFloat programs may be created. +For each build target, the target’s subdirectory is where all derived +object files and the completed TestFloat executables are created. +The template subdirectory is not an actual build target but +contains sample files for creating new target directories. +

+ +

+Ignoring the template directory, the supplied target directories +are intended to follow a naming system of +<execution-environment>-<compiler>. +For the example targets, +<execution-environment> is +Linux-386, Linux-386-SSE2, +Linux-x86_64, +Linux-ARM-VFPv2, Win32, +Win32-SSE2, or Win64, and +<compiler> is GCC, +MinGW, or MinGW-w64. +

+ +

+All of the supplied target directories are merely examples that may or may not +be correct for compiling on any particular system. +There are currently no plans to include and maintain in the TestFloat package +the build files needed for a great many users’ compilation environments, +which can span a huge range of operating systems, compilers, and other tools. +

+ +

+As supplied, each target directory contains two files: +

+
+Makefile
+platform.h
+
+
+The provided Makefile is written for GNU make. +A build of TestFloat for the specific target is begun by executing the +make command with the target directory as the current directory. +A completely different build tool can be used if an appropriate +Makefile equivalent is created. +

+ +

+The platform.h header file exists to provide a location for +additional C declarations specific to the build target. +Every C source file of TestFloat contains a #include for +platform.h. +In many cases, the contents of platform.h can be as simple as one +or two lines of code. +If the target’s compiler or library has bugs or other shortcomings, +workarounds for these issues may be possible with target-specific declarations +in platform.h, without the need to modify the main TestFloat +sources. +

+ +

+It may not be necessary to build all of the TestFloat programs. +For testing a floating-point implementation, typically +testfloat_gen and testfloat will not both be used, +and testfloat_ver may not be needed either. +The Makefile (or equivalent) can be modified not to create unneeded programs. +This may be especially relevant for the all-in-one test program +testfloat, which might not build without special attention. +

+ + +

5. Dependence on Berkeley SoftFloat

+ +

+In addition to the distributed sources, TestFloat depends on the existence of a +compatible Berkeley SoftFloat library and the corresponding header file +softfloat.h. +As mentioned earlier, SoftFloat is a separate package available at Web page +http://www.jhauser.us/arithmetic/SoftFloat.html. +The SoftFloat library must be compiled before the TestFloat programs can be +built. +In the example Makefiles, the locations of the SoftFloat header files and +pre-compiled library are specified by these macros: +

+
+
SOFTFLOAT_INCLUDE_DIR +
+The path of the directory containing softfloat.h, as well as other +nonstandard header files referenced by softfloat.h, if any. +
SOFTFLOAT_H +
+A list of the full paths of all SoftFloat header files needed by SoftFloat +clients. This list must include softfloat.h and may also include +other header files referenced by softfloat.h, such as +softfloat_types.h. +This macro is used only to establish build dependencies between the SoftFloat +header files and TestFloat’s source files, in case the SoftFloat header +files are changed. +
SOFTFLOAT_LIB +
+The full path of the compiled SoftFloat library (usually +softfloat.a or libsoftfloat.a). +
+
+

+ + +

6. Issues for Porting TestFloat to a New Target

+ +

6.1. Standard Headers <stdbool.h> and <stdint.h>

+ +

+The TestFloat sources make use of standard headers +<stdbool.h> and <stdint.h>, which have +been part of the ISO C Standard Library since 1999. +With any recent compiler, these standard headers are likely to be supported, +even if the compiler does not claim complete conformance to the latest ISO C +Standard. +For older or nonstandard compilers, substitutes for +<stdbool.h> and <stdint.h> may need to be +created. +TestFloat depends on these names from <stdbool.h>: +

+
+bool
+true
+false
+
+
+and on these names from <stdint.h>: +
+
+uint16_t
+uint32_t
+uint64_t
+int32_t
+int64_t
+UINT64_C
+INT64_C
+uint_least8_t
+uint_fast8_t
+uint_fast16_t
+uint_fast32_t
+uint_fast64_t
+int_fast8_t
+int_fast16_t
+int_fast32_t
+int_fast64_t
+
+
+

+ + +

6.2. Standard Header <fenv.h>

+ +

+Because the supplied all-in-one testfloat program tests the +floating-point operations of the C language, it uses the facilities provided by +standard C header <fenv.h> to access the floating-point +environment of C, in particular to set the rounding mode and to access the +floating-point exception flags. +Like <stdbool.h> and <stdint.h>, +<fenv.h> has been part of the ISO C Standard Library since +1999, but older or nonstandard C compilers may not support it. +

+ +

+Some form of standard header <fenv.h> is needed only if the +testfloat program is wanted and the program will not be +retargeted to invoke a floating-point implementation in a way that bypasses the +standard C environment. +Typically, if testfloat is wanted, it will be retargeted to invoke +a new floating-point implementation directly, making +<fenv.h> irrelevant. +For more about retargeting testfloat, see section 6.4 +below, Specializing the testfloat Program. +

+ + +

6.3. Macros for Build Options

+ +

+The TestFloat source files are affected by several C preprocessor macros: +

+
+
LITTLEENDIAN +
+Must be defined for little-endian machines; +must not be defined for big-endian machines. +
INLINE +
+Can be defined to a sequence of tokens used to indicate that a C function +should be inlined. +If the compiler does not support the inlining of functions, this macro must not +be defined. +For compilers that conform to the C Standard’s rules for inline +functions, this macro can be defined as the single keyword inline. +For other compilers that follow a convention pre-dating the standardization of +inline, this macro may need to be defined to extern +inline. +
THREAD_LOCAL +
+Can be defined to a sequence of tokens that, when appearing at the start of a +variable declaration, indicates to the C compiler that the variable is +per-thread, meaning that each execution thread gets its own separate +instance of the variable. +This macro is used in the supplied version of Berkeley SoftFloat’s header +softfloat.h, in the declarations of variables +softfloat_roundingMode, softfloat_detectTininess, +extF80_roundingPrecision, and +softfloat_exceptionFlags. +To use the supplied, unmodified header softfloat.h, this macro +must be defined (or not defined) the same as when the SoftFloat library was +built. +
+
+
FLOAT16 +
+Must be defined if the TestFloat programs are to support the +16-bit half-precision floating-point format. +
FLOAT64 +
+Must be defined if the TestFloat programs are to support the +64-bit double-precision floating-point format. +
EXTFLOAT80 +
+Must be defined if the TestFloat programs are to support the +80-bit double-extended-precision floating-point format. +
FLOAT128 +
+Must be defined if the TestFloat programs are to support the +128-bit quadruple-precision floating-point format. +
FLOAT_ROUND_ODD +
+Must be defined if the TestFloat programs are to support rounding to odd +(jamming). +To be useful, this option also requires that the Berkeley SoftFloat library was +compiled with macro SOFTFLOAT_ROUND_ODD defined. +
+
+Following the usual custom for C, for all the macros except +INLINE and THREAD_LOCAL, the content of a +macro’s definition is irrelevant; +what matters is a macro’s effect on #ifdef directives. +

+ +

+It is recommended that any definition of macros LITTLEENDIAN, +INLINE, and THREAD_LOCAL be made in a build +target’s platform.h header file, because these macros are +expected to be determined inflexibly by the target machine and compiler. +The other five macros select build options, and hence might be better located +in the target’s Makefile (or its equivalent). +

+ + +

6.4. Specializing the testfloat Program

+ +

+The supplied sources for the all-in-one testfloat program cause +testfloat to test the C compiler’s float and +double types for C operations +, -, +*, /, etc. +The supplied version is also capable of testing C type long +double if the sources are compiled with one of these macros +defined: +

+
+
LONG_DOUBLE_IS_EXTFLOAT80 +
+Indicates that type long double is +80-bit double-extended-precision floating-point. +
LONG_DOUBLE_IS_FLOAT128 +
+Indicates that type long double is +128-bit quadruple-precision floating-point. +
+
+By default, testfloat assumes that only the IEEE Standard’s +original four rounding modes (near_even, minMag, +min, and max) are supported by the floating-point +being tested. +For other rounding modes, additional macro can be defined: +
+
+
SUBJFLOAT_ROUND_NEAR_MAXMAG +
+Indicates that the subject floating-point supports rounding mode +near_maxMag (nearest/away). +
SUBJFLOAT_ROUND_ODD +
+Indicates that the subject floating-point supports rounding mode +odd (jamming). +
+
+

+ +

+To test a new and/or different implementation of floating-point, +testfloat must normally be retargeted to invoke this other +floating-point instead of C’s floating-point. +Two source files define the functions that testfloat uses to +invoke floating-point operations for testing: +

+
+subjfloat_config.h
+subjfloat.c
+
+
+For the default target of testing C’s floating-point, these files are +contained in directory source/subj-C as discussed +earlier. +For a different subject floating-point, it is recommended that appropriate +versions of subjfloat_config.h and subjfloat.c be +stored in a sibling subj-<target> +directory, where <target> names the particular +target. +

+ +

+Header file subjfloat_config.h defines a macro of the form +SUBJ_* for each subject function supported. +For example, if function subj_f32_add exists to perform +32-bit floating-point addition, then +subjfloat_config.h should have a definition for macro +SUBJ_F32_ADD. +The actual function subj_f32_add is expected to be defined in +subjfloat.c, along with all other subject functions. +A common header file, subjfloat.h, (not target-specific) provides +prototype declarations for all possible subject functions that +testfloat may be compiled to test, whether actually existing or +not. +(There is no penalty for the header to declare prototypes of nonexistent +functions that are never called.) +For a specific build of testfloat, the -list option +will list all subject functions that the testfloat program is able +to invoke and thus test. +

+ +

+In the source code as supplied, macros LONG_DOUBLE_IS_EXTFLOAT80 +and LONG_DOUBLE_IS_FLOAT128 affect only the target-specific source +files in source/subj-C, so these macros can be +ignored for any other subject floating-point that does not depend on them. +On the other hand, macros SUBJFLOAT_ROUND_NEAR_MAXMAG and +SUBJFLOAT_ROUND_ODD always determine whether the +testfloat program attempts to test rounding modes +near_maxMag and odd, regardless of the subject +floating-point. +

+ + +

6.5. Improving the Random Number Functions

+ +

+If you are serious about using TestFloat for testing floating-point, you should +consider replacing the random number functions in random.c. +The supplied random number functions are built on top of the standard C +rand function. +Because function rand is rather poor on some systems, the +functions in random.c assume very little about the quality of +rand. +As a result, rand is called more frequently than it might need to +be, shortening the time before random number sequences repeat, and possibly +wasting time as well. +If rand is better on a given target platform, or if another, +better random number generator is available (such as rand48 on +UNIX-derived systems), TestFloat can be improved by overriding the given +random.c with a target-specific one. +

+ +

+Rather than modifying the supplied file random.c, it is +recommended instead that a new, alternate file be created and the +target’s Makefile be modified to refer to that alternate file in place of +random.c. +

+ + +

7. Contact Information

+ +

+At the time of this writing, the most up-to-date information about TestFloat +and the latest release can be found at the Web page +http://www.jhauser.us/arithmetic/TestFloat.html. +

+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat.html new file mode 100644 index 000000000..34313cbba --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat.html @@ -0,0 +1,286 @@ + + + + +testfloat + + + + +

Berkeley TestFloat Release 3e: testfloat

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Overview

+ +

+The testfloat program tests an implementation of floating-point +arithmetic for conformity to the IEEE Standard for Binary Floating-Point +Arithmetic. +testfloat is part of the Berkeley TestFloat package, a small +collection of programs for performing such tests. +For general information about TestFloat, see file +TestFloat-general.html. +

+ +

+The testfloat program is an all-in-one tool for testing +floating-point arithmetic. +It generates test operand values, invokes a floating-point operation with the +generated operands, and examines the corresponding computed results, reporting +unexpected results as likely errors. +While the processes of generating inputs and examining results are generic, a +particular build of testfloat is limited to testing only the one +implementation of floating-point it has been compiled to invoke. +For example, while one instance of testfloat might be compiled to +execute a computer’s hardware instruction for floating-point addition, a +different version might be compiled to call a subroutine called +myAddFloat that is linked into the testfloat program. +To test a new implementation of floating-point (a new set of machine +instructions or a new set of subroutines), a new testfloat must be +compiled containing the code needed to invoke the new floating-point. +

+ +

+The default build of testfloat assumes that C types +float and double are 32-bit and +64-bit binary floating-point types conforming to the IEEE +Standard, and tests the C operations of +, -, +*, /, type conversions, etc. +This tests the floating-point arithmetic seen by C programs. +Depending on the compiler and the options selected during compilation, this may +or may not be the same as the computer’s floating-point hardware, if any. +

+ +

+The testfloat program will ordinarily test an operation for all +five rounding modes defined by the IEEE Floating-Point Standard, one after the +other, plus possibly a sixth mode, round to odd (depending on the +options selected when testfloat was compiled). +If the rounding mode is not supposed to have any affect on the +results—for instance, some operations do not require rounding—only +the nearest/even rounding mode is checked. +For double-extended-precision operations affected by rounding precision +control, testfloat also tests all three rounding precision modes, +one after the other. +Testing can be limited to a single rounding mode and/or rounding precision with +appropriate command-line options. +

+ +

+For more about the operation of testfloat and how to interpret its +output, refer to +TestFloat-general.html. +

+ + +

Command Syntax

+ +

+The testfloat program is executed as a command with this syntax: +

+
+testfloat [<option>...] <function>
+
+
+Square brackets ([ ]) denote optional arguments, +<option> is a supported option, and +<function> is the name of either a testable operation +or a function set. +The available options and function sets are documented below. +The -list option can be used to obtain a list of all testable +operations for a given build of testfloat. +If testfloat is executed without any arguments, a summary of usage +is written. +

+ + +

Options

+ +

+The testfloat program accepts several command options. +If mutually contradictory options are given, the last one has priority. +

+ +

-help

+ +

+The -help option causes a summary of program usage to be written, +after which the program exits. +

+ +

-list

+ +

+The -list option causes a list of testable operations to be +written, after which the program exits. +An operation is testable by testfloat if the program knows some +way to invoke the operation. +

+ +

-seed <num>

+ +

+The -seed option sets the seed for the pseudo-random number +generator used for generating test cases. +The argument to -seed is a nonnegative integer. +Executing the same compiled testfloat program with the same +arguments (including the same pseudo-random number seed) should always perform +the same sequence of tests, whereas changing the pseudo-random number seed +should result in a different sequence of tests. +The default seed number is 1. +

+ +

-level <num>

+ +

+The -level option sets the level of testing. +The argument to -level can be either 1 or 2. +The default is level 1. +Level 2 performs many more tests than level 1 and thus can reveal +bugs not found by level 1. +

+ +

-errors <num>

+ +

+The -errors option instructs testfloat to report no +more than the specified number of errors for any combination of operation, +rounding mode, etc. +The argument to -errors must be a nonnegative decimal integer. +Once the specified number of error reports has been generated, +testfloat ends the current test and begins the next one, if any. +The default is -errors 20. +

+ +

+Against intuition, -errors 0 causes +testfloat to report every error it finds. +

+ +

-errorstop

+ +

+The -errorstop option causes the program to exit after the first +operation for which any errors are reported. +

+ +

-forever

+ +

+The -forever option causes a single operation to be repeatedly +tested. +Only one rounding mode and/or rounding precision can be tested in a single +execution. +If not specified, the rounding mode defaults to nearest/even. +For 80-bit double-extended-precision operations, the rounding +precision defaults to full double-extended precision. +The testing level is set to 2 by this option. +

+ +

-checkNaNs

+ +

+The -checkNaNs option causes testfloat to verify the +bitwise correctness of NaN results. +In order for this option to be sensible, testfloat must have been +compiled so that its internal reference implementation of floating-point +(Berkeley SoftFloat) generates the proper NaN results for the system being +tested. +

+ +

-checkInvInts

+ +

+The -checkInvInts option causes testfloat to verify +the bitwise correctness of integer results of invalid operations. +In order for this option to be sensible, testfloat must have been +compiled so that its internal reference implementation of floating-point +(Berkeley SoftFloat) generates the proper integer results for the system being +tested. +

+ +

-checkAll

+ +

+Enables both -checkNaNs and -checkInvInts. +

+ +

-precision32, -precision64, -precision80

+ +

+For 80-bit double-extended-precision operations affected by +rounding precision control, the -precision32 option restricts +testing to only the cases in which the rounding precision is +32 bits, equivalent to 32-bit single-precision. +The other rounding precision choices are not tested. +Likewise, -precision64 fixes the rounding precision to +64 bits, equivalent to 64-bit double-precision, and +-precision80 fixes the rounding precision to the full +80 bits of the double-extended-precision format. +All these options are ignored for operations not affected by rounding precision +control. +

+ +

+The precision-control options may not be supported at all if no +double-extended-precision operations are testable. +

+ +

-rnear_even, -rnear_maxMag, -rminMag, -rmin, -rmax, -rodd

+ +

+The -rnear_even option restricts testing to only the cases in +which the rounding mode is nearest/even. +The other rounding mode choices are not tested. +Likewise, -rnear_maxMag forces rounding to nearest/maximum +magnitude (nearest-away), -rminMag forces rounding to minimum +magnitude (toward zero), -rmin forces rounding to minimum (down, +toward negative infinity), -rmax forces rounding to maximum (up, +toward positive infinity), and -rodd, if supported, forces +rounding to odd. +These options are ignored for operations that are exact and thus do not round, +or that have the rounding mode included in the function name (such as +f32_to_i32_r_near_maxMag). +

+ +

-tininessbefore, -tininessafter

+ +

+The -tininessbefore option indicates that the floating-point +implementation being tested detects tininess on underflow before rounding. +The -tininessafter option indicates that tininess is detected +after rounding. +The testfloat program alters its expectations accordingly. +These options override the default selected when testfloat was +compiled. +Choosing the wrong one of these two options should cause error reports for some +(but not all) operations. +

+ + +

Function Sets

+ +

+Just as testfloat can test an operation for all five or six +rounding modes in sequence, multiple operations can be tested with a single +execution of testfloat. +Two sets are recognized: -all1 and -all2. +The set -all1 is all one-operand operations, while +-all2 is all two-operand operations. +A function set is used in place of an operation name in the +testfloat command line, such as +

+
+testfloat [<option>...] -all1
+
+
+

+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_gen.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_gen.html new file mode 100644 index 000000000..dfc5abe02 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_gen.html @@ -0,0 +1,367 @@ + + + + +testfloat_gen + + + + +

Berkeley TestFloat Release 3e: testfloat_gen

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Overview

+ +

+The testfloat_gen program generates test cases for testing that an +implementation of floating-point arithmetic conforms to the IEEE Standard for +Binary Floating-Point Arithmetic. +testfloat_gen is part of the Berkeley TestFloat package, a small +collection of programs for performing such tests. +For general information about TestFloat, see file +TestFloat-general.html. +

+ +

+A single execution of testfloat_gen generates test cases for only +a single floating-point operation and associated options. +The testfloat_gen program must be repeatedly executed to generate +test cases for each operation to be tested. +

+ +

+The testfloat_gen program writes the test cases it generates to +standard output. +This output can either be captured in a file through redirection, or be piped +to another program that exercises a floating-point operation using the test +cases as they are supplied. +Depending on use, the total output from testfloat_gen can be +large, so piping to another program may be the best choice to avoid using +inordinate file space. +The format of testfloat_gen’s output is raw hexadecimal +text, described in the section below titled Output Format. +

+ + +

Command Syntax

+ +

+The testfloat_gen program is executed as a command in one of these +forms: +

+
+testfloat_gen [<option>...] <type>
+testfloat_gen [<option>...] <function>
+
+
+Square brackets ([ ]) denote optional arguments, and +<option> is a supported option, documented below. +A testfloat_gen command expects either a +<type> specifying the type and number of outputs or a +<function> naming a floating-point operation. +If testfloat_gen is executed without any arguments, a summary of +usage is written. +

+ +

+A <type> can be one of the following: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ui32unsigned 32-bit integers
ui64unsigned 64-bit integers
i32signed 32-bit integers
i64signed 64-bit integers
f16 [<num>]one or more 16-bit half-precision floating-point values
f32 [<num>]one or more 32-bit single-precision floating-point values
f64 [<num>]one or more 64-bit double-precision floating-point values
extF80 [<num>]   one or more 80-bit double-extended-precision floating-point +values
f128 [<num>]one or more 128-bit quadruple-precision floating-point +values
+
+Optional <num> is one of 1, 2, or 3. +If a <type> is given without +<num> (such as ui32 or +f64), testfloat_gen outputs a list of values of the +specified type, one value per line, appropriate for testing a floating-point +operation with exactly one operand of the given type. +If a floating-point type and number are given (such as +f32 2 or +extF80 1), testfloat_gen +outputs the specified number of values per line, appropriate for testing a +floating-point operation with that number of operands. +Although the exact operation being tested is not specified, the test cases +output by testfloat_gen cover all standard floating-point +operations, to the degree explained in +TestFloat-general.html. +

+ +

+If a <function> operation name is given, then each +line of output from testfloat_gen contains not only the operands +for that operation (as would be generated by an appropriate +<type> argument) but also the expected results as +determined by testfloat_gen’s internal floating-point +emulation (Berkeley SoftFloat). +The available operation names are listed in +TestFloat-general.html. +In all cases, floating-point operations have two results: +first, a value, which may be floating-point, integer, or Boolean, and, second, +the floating-point exception flags raised by the operation. +If the output from a tested floating-point operation does not match the +expected output specified by testfloat_gen, this may or may not +indicate an error in the floating-point operation. +For further explanation, see +TestFloat-general.html, +especially the section titled Variations Allowed by the IEEE Floating-Point +Standard. +

+ + +

Options

+ +

+The testfloat_gen program accepts several command options. +If mutually contradictory options are given, the last one has priority. +

+ +

-help

+ +

+The -help option causes a summary of program usage to be written, +after which the program exits. +

+ +

-prefix <text>

+ +

+The -prefix option causes testfloat_gen to write the +supplied text argument verbatim as the first line of output before any test +cases. +This can be used, for example, to indicate to a downstream program what kind of +test to perform for the test cases that follow. +

+ +

-seed <num>

+ +

+The -seed option sets the seed for the pseudo-random number +generator used for generating test cases. +The argument to -seed is a nonnegative integer. +Executing the same testfloat_gen program with the same arguments +(including the same pseudo-random number seed) should always generate the same +sequence of test cases, whereas changing the pseudo-random number seed should +result in a different sequence of test cases. +The default seed number is 1. +

+ +

-level <num>

+ +

+The -level option sets the level of testing. +The argument to -level can be either 1 or 2. +The default is level 1. +Level 2 causes many more test cases to be generated, with better +coverage, than level 1. +

+ +

-n <num>

+ +

+Option -n specifies the number of test cases to generate. +For each <type> or +<function> and each testing level (set by +-level), there is a minimum value that testfloat_gen +will accept for <num>. +If no -n option is given, the number of test cases generated by +testfloat_gen equals the minimum value acceptable for the +-n argument. +Option -n cannot be used to reduce this number, but can increase +it, without changing the testing level. +

+ +

-forever

+ +

+The -forever option causes test cases to be generated +indefinitely, without limit (until the program is terminated by some external +cause). +The testing level is set to 2 by this option. +

+ +

-precision32, -precision64, -precision80

+ +

+When a <function> is specified that is an +80-bit double-extended-precision operation affected by rounding +precision control, the -precision32 option sets the rounding +precision to 32 bits, equivalent to 32-bit +single-precision. +Likewise, -precision64 sets the rounding precision to +64 bits, equivalent to 64-bit double-precision, and +-precision80 sets the rounding precision to the full +80 bits of the double-extended-precision format. +All these options are ignored for operations not affected by rounding precision +control. +When rounding precision is applicable but not specified, the default is the +full 80 bits, same as -precision80. +

+ +

-rnear_even, -rnear_maxMag, -rminMag, -rmin, -rmax, -rodd

+ +

+When a <function> is specified that requires +rounding, the -rnear_even option sets the rounding mode to +nearest/even; +-rnear_maxMag sets rounding to nearest/maximum magnitude +(nearest-away); +-rminMag sets rounding to minimum magnitude (toward zero); +-rmin sets rounding to minimum (down, toward negative infinity); +-rmax sets rounding to maximum (up, toward positive infinity); +and -rodd, if supported, sets rounding to odd. +These options are ignored for operations that are exact and thus do not round. +When rounding mode is relevant but not specified, the default is to round to +nearest/even, same as -rnear_even. +

+ +

-tininessbefore, -tininessafter

+ +

+When a <function> is specified that requires +rounding, the -tininessbefore option indicates that tininess on +underflow will be detected before rounding, while -tininessafter +indicates that tininess on underflow will be detected after rounding. +These options are ignored for operations that are exact and thus do not round. +When the method of tininess detection matters but is not specified, the default +is to detect tininess on underflow after rounding, same as +-tininessafter. +

+ +

-notexact, -exact

+ +

+When a <function> is specified that rounds to an +integer (either conversion to an integer type or a roundToInt +operation), the -notexact option indicates that the inexact +exception flag is never raised, while -exact indicates that the +inexact exception flag is to be raised if the result is inexact. +For other operations, these options are ignored. +If neither option is specified, the default is not to raise the inexact +exception flag when rounding to an integer, same as -notexact. +

+ + +

Output Format

+ +

+For each test case generated, testfloat_gen writes a single line +of text to standard output. +When the testfloat_gen command is given a +<type> argument, each test case consists of either +one integer value or one, two, or three floating-point values. +Each value is written to output as a raw hexadecimal number. +When there is more than one value per line, they are separated by spaces. +For example, output from executing +

+
+testfloat_gen f64 2
+
+
+might look like this: +
+
+3F90EB5825D6851E C3E0080080000000
+41E3C00000000000 C182024F8AE474A8
+7FD80FFFFFFFFFFF 7FEFFFFFFFFFFF80
+3FFFED6A25C534BE 3CA1000000020000
+...
+
+
+with each hexadecimal number being one 64-bit floating-point +value. +Note that, for floating-point values, the sign and exponent are at the +most-significant end of the number. +Thus, for the first number on the first line above, the leading hexadecimal +digits 3F9 are the sign and encoded exponent of the +64-bit floating-point value, and the remaining digits are the +encoded significand. +

+ +

+When testfloat_gen is given a <function> +operation name, each line of output has not only the operands for the operation +but also the expected output, consisting of a result value and the exception +flags that are raised. +For example, the output from +

+
+testfloat_gen f64_add
+
+
+could include these lines: +
+
+3F90EB5825D6851E C3E0080080000000 C3E0080080000000 01
+41E3C00000000000 C182024F8AE474A8 41E377F6C1D46E2D 01
+7FD80FFFFFFFFFFF 7FEFFFFFFFFFFF80 7FF0000000000000 05
+3FFFED6A25C534BE 3CA1000000020000 3FFFED6A25C534BF 01
+...
+
+
+On each line, the first two numbers are the operands for the floating-point +addition, and the third and fourth numbers are the expected floating-point +result (the sum) and the exception flags raised. +Exception flags are encoded with one bit per flag as follows: +
+ + + + + + + + + + + + +
bit 0   inexact exception
bit 1underflow exception
bit 2overflow exception
bit 3infinite exception (“divide by zero”)
bit 4invalid exception
+
+

+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_ver.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_ver.html new file mode 100644 index 000000000..83c6ea82d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testfloat_ver.html @@ -0,0 +1,270 @@ + + + + +testfloat_ver + + + + +

Berkeley TestFloat Release 3e: testfloat_ver

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Overview

+ +

+The testfloat_ver program accepts test-case results obtained from +exercising an implementation of floating-point arithmetic and verifies that +those results conform to the IEEE Standard for Binary Floating-Point +Arithmetic. +testfloat_ver is part of the Berkeley TestFloat package, a small +collection of programs for performing such tests. +For general information about TestFloat, see file +TestFloat-general.html. +

+ +

+A single execution of testfloat_ver verifies results for only a +single floating-point operation and associated options. +The testfloat_ver program must be repeatedly executed to verify +results for each operation to be tested. +

+ +

+The test cases to be verified are read by testfloat_ver from +standard input. +This input will typically be piped from another program that, for each test +case, invokes the floating-point operation and writes out the results. +The format of testfloat_ver’s input is raw hexadecimal text, +described in the section below titled Input Format. +

+ +

+For each test case given to it, testfloat_ver examines the +computed results and reports any unexpected results as likely errors. + +For more about the operation of testfloat_ver and how to interpret +its output, refer to +TestFloat-general.html. +

+ + +

Command Syntax

+ +

+The testfloat_ver program is executed as a command with this +syntax: +

+
+testfloat_ver [<option>...] <function>
+
+
+Square brackets ([ ]) denote optional arguments, +<option> is a supported option, and +<function> is the name of a testable operation. +The available options are documented below. +The testable operation names are listed in +TestFloat-general.html. +If testfloat_ver is executed without any arguments, a summary of +usage is written. +

+ + +

Options

+ +

+The testfloat_ver program accepts several command options. +If mutually contradictory options are given, the last one has priority. +

+ +

-help

+ +

+The -help option causes a summary of program usage to be written, +after which the program exits. +

+ +

-errors <num>

+ +

+The -errors option instructs testfloat_ver to report +no more than the specified number of errors. +The argument to -errors must be a nonnegative decimal integer. +Once the specified number of error reports has been generated, the program +exits. +The default is -errors 20. +

+ +

+Against intuition, -errors 0 causes +testfloat_ver to continue for any number of errors. +

+ +

-checkNaNs

+ +

+The -checkNaNs option causes testfloat_ver to verify +the bitwise correctness of NaN results. +In order for this option to be sensible, testfloat_ver must have +been compiled so that its internal reference implementation of floating-point +(Berkeley SoftFloat) generates the proper NaN results for the system being +tested. +

+ +

-checkInvInts

+ +

+The -checkInvInts option causes testfloat_ver to +verify the bitwise correctness of integer results of invalid operations. +In order for this option to be sensible, testfloat_ver must have +been compiled so that its internal reference implementation of floating-point +(Berkeley SoftFloat) generates the proper integer results for the system being +tested. +

+ +

-checkAll

+ +

+Enables both -checkNaNs and -checkInvInts. +

+ +

-precision32, -precision64, -precision80

+ +

+When <function> is an 80-bit +double-extended-precision operation affected by rounding precision control, the +-precision32 option indicates that the rounding precision should +be 32 bits, equivalent to 32-bit single-precision. +Likewise, -precision64 indicates that the rounding precision +should be 64 bits, equivalent to 64-bit +double-precision, and -precision80 indicates that the rounding +precision should be the full 80 bits of the +double-extended-precision format. +All these options are ignored for operations not affected by rounding precision +control. +When rounding precision is applicable but not specified, the default assumption +is the full 80 bits, same as -precision80. +

+ +

-rnear_even, -rnear_maxMag, -rminMag, -rmin, -rmax, -rodd

+ +

+When <function> is an operation that requires +rounding, the -rnear_even option indicates that rounding should be +to nearest/even, -rnear_maxMag indicates rounding to +nearest/maximum magnitude (nearest-away), -rminMag indicates +rounding to minimum magnitude (toward zero), -rmin indicates +rounding to minimum (down, toward negative infinity), -rmax +indicates rounding to maximum (up, toward positive infinity), and +-rodd, if supported, indicates rounding to odd. +These options are ignored for operations that are exact and thus do not round. +When rounding mode is relevant but not specified, the default assumption is +rounding to nearest/even, same as -rnear_even. +

+ +

-tininessbefore, -tininessafter

+ +

+When <function> is an operation that requires +rounding, the -tininessbefore option indicates that tininess on +underflow should be detected before rounding, while -tininessafter +indicates that tininess on underflow should be detected after rounding. +These options are ignored for operations that are exact and thus do not round. +When the method of tininess detection matters but is not specified, the default +assumption is that tininess should be detected after rounding, same as +-tininessafter. +

+ +

-notexact, -exact

+ +

+When <function> is an operation that rounds to an +integer (either conversion to an integer type or a roundToInt +operation), the -notexact option indicates that the inexact +exception flag should never be raised, while -exact indicates that +the inexact exception flag should be raised when the result is inexact. +For other operations, these options are ignored. +If neither option is specified, the default assumption is that the +inexact exception flag should not be raised when rounding to an integer, +same as -notexact. +

+ + +

Input Format

+ +

+For a given <function> argument, the input format +expected by testfloat_ver is the same as the output generated by +program +testfloat_gen for +the same argument. +

+ +

+Input to testfloat_ver is expected to be text, with each line +containing the data for one test case. +The number of input lines thus equals the number of test cases. +A single test case is organized as follows: first are the operands for the +operation, next is the result value obtained, and last is a number indicating +the exception flags that were raised. +These values are all expected to be provided as raw hexadecimal numbers +separated on the line by spaces. +For example, for the command +

+
+testfloat_ver f64_add
+
+
+valid input could include these lines: +
+
+3F90EB5825D6851E C3E0080080000000 C3E0080080000000 01
+41E3C00000000000 C182024F8AE474A8 41E377F6C1D46E2D 01
+7FD80FFFFFFFFFFF 7FEFFFFFFFFFFF80 7FF0000000000000 05
+3FFFED6A25C534BE 3CA1000000020000 3FFFED6A25C534BF 01
+...
+
+
+On each line above, the first two hexadecimal numbers represent the +64-bit floating-point operands, the third hexadecimal number is +the 64-bit floating-point result of the operation (the sum), and +the last hexadecimal number gives the exception flags that were raised by the +operation. +

+ +

+Note that, for floating-point values, the sign and exponent are at the +most-significant end of the number. +Thus, for the first number on the first line above, the leading hexadecimal +digits 3F9 are the sign and encoded exponent of the +64-bit floating-point value, and the remaining digits are the +encoded significand. +

+ +

+Exception flags are encoded with one bit per flag as follows: +

+ + + + + + + + + + + + +
bit 0   inexact exception
bit 1underflow exception
bit 2overflow exception
bit 3infinite exception (“divide by zero”)
bit 4invalid exception
+
+

+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/testsoftfloat.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testsoftfloat.html new file mode 100644 index 000000000..cd8af6921 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/testsoftfloat.html @@ -0,0 +1,236 @@ + + + + +testsoftfloat + + + + +

Berkeley TestFloat Release 3e: testsoftfloat

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Overview

+ +

+The testsoftfloat program tests that a build of the Berkeley +SoftFloat library conforms to the IEEE Standard for Binary Floating-Point +Arithmetic as expected. +Program testsoftfloat is part of the Berkeley TestFloat package, a +small collection of programs for performing such tests. +For general information about TestFloat, as well as for basics about the +operation of testsoftfloat and how to interpret its output, see +file +TestFloat-general.html. +

+ +

+Note that, even if there are no bugs in the source code for SoftFloat (not +guaranteed), a build of SoftFloat might still fail due to an issue with the +build process, such as an incompatible compiler option or a compiler bug. +

+ +

+The testsoftfloat program will ordinarily test a function for all +five rounding modes defined by the IEEE Floating-Point Standard, one after the +other, plus possibly a sixth mode, round to odd (depending on the +options selected when testsoftfloat was compiled). +If an operation is not supposed to require rounding, it will by default be +tested only with the rounding mode set to near_even +(nearest/even). +In the same way, if an operation is affected by the way in which underflow +tininess is detected, testsoftfloat tests the function with +tininess detected both before rounding and after rounding. +For 80-bit double-extended-precision operations affected by +rounding precision control, testsoftfloat also tests the function +for all three rounding precision modes, one after the other. +Testing can be limited to a single rounding mode, a single tininess mode, +and/or a single rounding precision with appropriate command-line options. +

+ + +

Command Syntax

+ +

+The testsoftfloat program is executed as a command with this +syntax: +

+
+testsoftfloat [<option>...] <function>
+
+
+Square brackets ([ ]) denote optional arguments, +<option> is a supported option, and +<function> is the name of either a testable function +or a function set. +The available options and function sets are documented below. +If testsoftfloat is executed without any arguments, a summary of +usage is written. +

+ + +

Options

+ +

+The testsoftfloat program accepts several command options. +If mutually contradictory options are given, the last one has priority. +

+ +

-help

+ +

+The -help option causes a summary of program usage to be written, +after which the program exits. +

+ +

-seed <num>

+ +

+The -seed option sets the seed for the pseudo-random number +generator used for generating test cases. +The argument to -seed is a nonnegative integer. +Executing the same testsoftfloat program with the same arguments +(including the same pseudo-random number seed) should always perform the same +sequence of tests, whereas changing the pseudo-random number seed should result +in a different sequence of tests. +The default seed number is 1. +

+ +

-level <num>

+ +

+The -level option sets the level of testing. +The argument to -level can be either 1 or 2. +The default is level 1. +Level 2 performs many more tests than level 1 and thus can reveal +bugs not found by level 1. +

+ +

-errors <num>

+ +

+The -errors option instructs testsoftfloat to report +no more than the specified number of errors for any combination of function, +rounding mode, etc. +The argument to -errors must be a nonnegative decimal integer. +Once the specified number of error reports has been generated, +testsoftfloat ends the current test and begins the next one, if +any. +The default is -errors 20. +

+ +

+Against intuition, -errors 0 causes +testsoftfloat to report every error it finds. +

+ +

-errorstop

+ +

+The -errorstop option causes the program to exit after the first +function for which any errors are reported. +

+ +

-forever

+ +

+The -forever option causes a single function to be repeatedly +tested. +Only one rounding mode and/or rounding precision can be tested in a single +execution. +If not specified, the rounding mode defaults to nearest/even. +For 80-bit double-extended-precision functions, the rounding +precision defaults to full double-extended precision. +The testing level is set to 2 by this option. +

+ +

-precision32, -precision64, -precision80

+ +

+For 80-bit double-extended-precision funcions affected by +rounding precision control, the -precision32 option restricts +testing to only the cases in which the rounding precision is +32 bits, equivalent to 32-bit single-precision. +The other rounding precision choices are not tested. +Likewise, -precision64 fixes the rounding precision to +64 bits, equivalent to 64-bit double-precision; +and -precision80 fixes the rounding precision to the full +80 bits of the double-extended-precision format. +All these options are ignored for operations not affected by rounding precision +control. +

+ +

-rnear_even, -rnear_maxMag, -rminMag, -rmin, -rmax, -rodd

+ +

+The -rnear_even option restricts testing to only the cases in +which the rounding mode is nearest/even. +The other rounding mode choices are not tested. +Likewise, -rnear_maxMag forces rounding to nearest/maximum +magnitude (nearest-away), -rminMag forces rounding to minimum +magnitude (toward zero), -rmin forces rounding to minimum (down, +toward negative infinity), -rmax forces rounding to maximum (up, +toward positive infinity), and -rodd, if supported, forces +rounding to odd. +These options are ignored for operations that are exact and thus do not round. +

+ +

-tininessbefore, -tininessafter

+ +

+The -tininessbefore option restricts testing to only the cases in +which tininess on underflow is detected before rounding. +Likewise, -tininessafter restricts testing to only the cases in +which tininess on underflow is detected after rounding. +

+ +

-notexact, -exact

+ +

+For functions that round to an integer (conversions to integer types and the +roundToInt functions), the -notexact option restricts +testing to only the cases for which the exact operand +(specifying whether the inexact exception flag may be raised) is +false. +Likewise, the -exact option restricts testing to only the cases +for which the exact operand is true. +

+ + +

Function Sets

+ +

+Just as testsoftfloat can test a function for all five or six +rounding modes in sequence, multiple functions can be tested with a single +execution of testsoftfloat. +Two sets are recognized: -all1 and -all2. +The set -all1 is all one-operand operations, while +-all2 is all two-operand operations. +A function set is used in place of a function name in the +testsoftfloat command line, such as +

+
+testsoftfloat [<option>...] -all1
+
+
+

+ +

+For the purpose of deciding the number of operands of an operation, any +roundingMode and exact arguments are +ignored. +(Such arguments specify the rounding mode and whether the inexact +exception flag may be raised, respectively.) +Thus, functions that convert to integer type and the roundToInt +functions are included in the set of one-operand operations tested by +-all1. +

+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/doc/timesoftfloat.html b/wally-pipelined/testbench/fp/TestFloat-3e/doc/timesoftfloat.html new file mode 100644 index 000000000..bb7264784 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/doc/timesoftfloat.html @@ -0,0 +1,196 @@ + + + + +timesoftfloat + + + + +

Berkeley TestFloat Release 3e: timesoftfloat

+ +

+John R. Hauser
+2018 January 20
+

+ + +

Overview

+ +

+The timesoftfloat program provides a simple way to evaluate the +speed of the floating-point operations of the Berkeley SoftFloat library. +Program timesoftfloat is included with the Berkeley TestFloat +package, a small collection of programs for testing that an implementation of +floating-point conforms to the IEEE Standard for Binary Floating-Point +Arithmetic. +Although timesoftfloat does not test floating-point correctness +like the other TestFloat programs, nevertheless timesoftfloat is a +partner to TestFloat’s testsoftfloat program. +For more about TestFloat generally and testsoftfloat specifically, +see file +TestFloat-general.html. +

+ +

+Ordinarily, timesoftfloat will measure a function’s speed +separately for each of the five rounding modes defined by the IEEE +Floating-Point Standard, one after the other, plus possibly a sixth mode, +round to odd (depending on the options selected when +timesoftfloat was compiled). +If an operation is not supposed to require rounding, it will by default be +timed only with the rounding mode set to near_even (nearest/even). +In the same way, if an operation is affected by the way in which underflow +tininess is detected, timesoftfloat times the function with +tininess detected both before rounding and after rounding. +For 80-bit double-extended-precision operations affected by +rounding precision control, timesoftfloat also times the function +for each of the three rounding precision modes, one after the other. +Evaluation of a function can be limited to a single rounding mode, a single +tininess mode, and/or a single rounding precision with appropriate command-line +options. +

+ +

+For each function and mode evaluated, timesoftfloat reports the +measured speed of the function in Mop/s, or “millions of operations per +second”. +The speeds reported by timesoftfloat may be affected somewhat by +other software executing at the same time as timesoftfloat. +Be aware also that the exact execution time of any SoftFloat function depends +partly on the values of arguments and the state of the processor’s caches +at the time the function is called. +Your actual experience with SoftFloat may differ from the speeds reported by +timesoftfloat for all these reasons. +

+ +

+Note that the remainder operations for larger formats (f64_rem, +extF80_rem, and f128_rem) can be markedly slower than +other operations, particularly for double-extended-precision +(extF80_rem) and quadruple precision (f128_rem). +This is inherent to the remainder operation itself and is not a failing of the +SoftFloat implementation. +

+ + +

Command Syntax

+ +

+The timesoftfloat program is executed as a command with this +syntax: +

+
+timesoftfloat [<option>...] <function>
+
+
+Square brackets ([ ]) denote optional arguments, +<option> is a supported option, and +<function> is the name of either a testable function +or a function set. +The available options and function sets are documented below. +If timesoftfloat is executed without any arguments, a summary of +usage is written. +

+ + +

Options

+ +

+The timesoftfloat program accepts several command options. +If mutually contradictory options are given, the last one has priority. +

+ +

-help

+ +

+The -help option causes a summary of program usage to be written, +after which the program exits. +

+ +

-precision32, -precision64, -precision80

+ +

+For 80-bit double-extended-precision funcions affected by +rounding precision control, the -precision32 option restricts +timing of an operation to only the cases in which the rounding precision is +32 bits, equivalent to 32-bit single-precision. +Other rounding precision choices are not timed. +Likewise, -precision64 fixes the rounding precision to +64 bits, equivalent to 64-bit double-precision; +and -precision80 fixes the rounding precision to the full +80 bits of the double-extended-precision format. +All these options are ignored for operations not affected by rounding precision +control. +

+ +

-rnear_even, -rnear_maxMag, -rminMag, -rmin, -rmax, -rodd

+ +

+The -rnear_even option restricts timing of an operation to only +the cases in which the rounding mode is nearest/even. +Other rounding mode choices are not timed. +Likewise, -rnear_maxMag forces rounding to nearest/maximum +magnitude (nearest-away), -rminMag forces rounding to minimum +magnitude (toward zero), -rmin forces rounding to minimum (down, +toward negative infinity), -rmax forces rounding to maximum (up, +toward positive infinity), and -rodd, if supported, forces +rounding to odd. +These options are ignored for operations that are exact and thus do not round. +

+ +

-tininessbefore, -tininessafter

+ +

+The -tininessbefore option restricts timing of an operation to +only the cases in which tininess on underflow is detected before rounding. +Likewise, -tininessafter restricts measurement to only the cases +in which tininess on underflow is detected after rounding. +

+ +

-notexact, -exact

+ +

+For functions that round to an integer (conversions to integer types and the +roundToInt functions), the -notexact option restricts +timing of an operation to only the cases for which the +exact operand (specifying whether the inexact +exception flag may be raised) is false. +Likewise, the -exact option restricts measurement to only the +cases for which the exact operand is true. +

+ + +

Function Sets

+ +

+Just as timesoftfloat can time a function for all five or six +rounding modes in sequence, multiple functions can be timed with a single +execution of timesoftfloat. +Three sets are recognized: +-all1, -all2, and -all. +The set -all1 is all one-operand operations, -all2 is +all two-operand operations, and -all is obviously all operations. +A function set is used in place of a function name in the +timesoftfloat command line, such as +

+
+timesoftfloat [<option>...] -all1
+
+
+

+ +

+For the purpose of deciding the number of operands of an operation, any +roundingMode and exact arguments are +ignored. +(Such arguments specify the rounding mode and whether the inexact +exception flag may be raised, respectively.) +Thus, functions that convert to integer type and the roundToInt +functions are included in the set of one-operand operations timed by +-all1. +

+ + + + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/fail.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/fail.c new file mode 100644 index 000000000..dae6c6422 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/fail.c @@ -0,0 +1,59 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include +#include "platform.h" +#include "fail.h" + +char *fail_programName = ""; + +void fail( const char *messagePtr, ... ) +{ + va_list varArgs; + + fflush( 0 ); + fprintf( stderr, "%s: ", fail_programName ); + va_start( varArgs, messagePtr ); + vfprintf( stderr, messagePtr, varArgs ); + va_end( varArgs ); + fputs( ".\n", stderr ); + exit( EXIT_FAILURE ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/fail.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/fail.h new file mode 100644 index 000000000..0f1f48f78 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/fail.h @@ -0,0 +1,41 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +extern char *fail_programName; + +void fail( const char *, ... ); + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/functionInfos.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/functionInfos.c new file mode 100644 index 000000000..e4d25e3fd --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/functionInfos.c @@ -0,0 +1,290 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "functions.h" + +#define ARG_1 FUNC_ARG_UNARY +#define ARG_2 FUNC_ARG_BINARY +#define ARG_R FUNC_ARG_ROUNDINGMODE +#define ARG_E FUNC_ARG_EXACT +#define EFF_P FUNC_EFF_ROUNDINGPRECISION +#define EFF_R FUNC_EFF_ROUNDINGMODE +#define EFF_T FUNC_EFF_TININESSMODE +#define EFF_T_REDP FUNC_EFF_TININESSMODE_REDUCEDPREC + +/*---------------------------------------------------------------------------- +| Warning: This array must match the list of macros defined in "functions.h". +*----------------------------------------------------------------------------*/ +const struct functionInfo functionInfos[NUM_FUNCTIONS] = { + { 0, 0 }, + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 + { "ui32_to_f16", ARG_1 | EFF_R }, +#endif + { "ui32_to_f32", ARG_1 | EFF_R }, +#ifdef FLOAT64 + { "ui32_to_f64", ARG_1 }, +#endif +#ifdef EXTFLOAT80 + { "ui32_to_extF80", ARG_1 }, +#endif +#ifdef FLOAT128 + { "ui32_to_f128", ARG_1 }, +#endif +#ifdef FLOAT16 + { "ui64_to_f16", ARG_1 | EFF_R }, +#endif + { "ui64_to_f32", ARG_1 | EFF_R }, +#ifdef FLOAT64 + { "ui64_to_f64", ARG_1 | EFF_R }, +#endif +#ifdef EXTFLOAT80 + { "ui64_to_extF80", ARG_1 }, +#endif +#ifdef FLOAT128 + { "ui64_to_f128", ARG_1 }, +#endif +#ifdef FLOAT16 + { "i32_to_f16", ARG_1 | EFF_R }, +#endif + { "i32_to_f32", ARG_1 | EFF_R }, +#ifdef FLOAT64 + { "i32_to_f64", ARG_1 }, +#endif +#ifdef EXTFLOAT80 + { "i32_to_extF80", ARG_1 }, +#endif +#ifdef FLOAT128 + { "i32_to_f128", ARG_1 }, +#endif +#ifdef FLOAT16 + { "i64_to_f16", ARG_1 | EFF_R }, +#endif + { "i64_to_f32", ARG_1 | EFF_R }, +#ifdef FLOAT64 + { "i64_to_f64", ARG_1 | EFF_R }, +#endif +#ifdef EXTFLOAT80 + { "i64_to_extF80", ARG_1 }, +#endif +#ifdef FLOAT128 + { "i64_to_f128", ARG_1 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 + { "f16_to_ui32", ARG_1 | ARG_R | ARG_E }, + { "f16_to_ui64", ARG_1 | ARG_R | ARG_E }, + { "f16_to_i32", ARG_1 | ARG_R | ARG_E }, + { "f16_to_i64", ARG_1 | ARG_R | ARG_E }, + { "f16_to_ui32_r_minMag", ARG_1 | ARG_E }, + { "f16_to_ui64_r_minMag", ARG_1 | ARG_E }, + { "f16_to_i32_r_minMag", ARG_1 | ARG_E }, + { "f16_to_i64_r_minMag", ARG_1 | ARG_E }, + { "f16_to_f32", ARG_1 }, +#ifdef FLOAT64 + { "f16_to_f64", ARG_1 }, +#endif +#ifdef EXTFLOAT80 + { "f16_to_extF80", ARG_1 }, +#endif +#ifdef FLOAT128 + { "f16_to_f128", ARG_1 }, +#endif + { "f16_roundToInt", ARG_1 | ARG_R | ARG_E }, + { "f16_add", ARG_2 | EFF_R }, + { "f16_sub", ARG_2 | EFF_R }, + { "f16_mul", ARG_2 | EFF_R | EFF_T }, + { "f16_mulAdd", EFF_R | EFF_T }, + { "f16_div", ARG_2 | EFF_R }, + { "f16_rem", ARG_2 }, + { "f16_sqrt", ARG_1 | EFF_R }, + { "f16_eq", ARG_2 }, + { "f16_le", ARG_2 }, + { "f16_lt", ARG_2 }, + { "f16_eq_signaling", ARG_2 }, + { "f16_le_quiet", ARG_2 }, + { "f16_lt_quiet", ARG_2 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + { "f32_to_ui32", ARG_1 | ARG_R | ARG_E }, + { "f32_to_ui64", ARG_1 | ARG_R | ARG_E }, + { "f32_to_i32", ARG_1 | ARG_R | ARG_E }, + { "f32_to_i64", ARG_1 | ARG_R | ARG_E }, + { "f32_to_ui32_r_minMag", ARG_1 | ARG_E }, + { "f32_to_ui64_r_minMag", ARG_1 | ARG_E }, + { "f32_to_i32_r_minMag", ARG_1 | ARG_E }, + { "f32_to_i64_r_minMag", ARG_1 | ARG_E }, +#ifdef FLOAT16 + { "f32_to_f16", ARG_1 | EFF_R | EFF_T }, +#endif +#ifdef FLOAT64 + { "f32_to_f64", ARG_1 }, +#endif +#ifdef EXTFLOAT80 + { "f32_to_extF80", ARG_1 }, +#endif +#ifdef FLOAT128 + { "f32_to_f128", ARG_1 }, +#endif + { "f32_roundToInt", ARG_1 | ARG_R | ARG_E }, + { "f32_add", ARG_2 | EFF_R }, + { "f32_sub", ARG_2 | EFF_R }, + { "f32_mul", ARG_2 | EFF_R | EFF_T }, + { "f32_mulAdd", EFF_R | EFF_T }, + { "f32_div", ARG_2 | EFF_R }, + { "f32_rem", ARG_2 }, + { "f32_sqrt", ARG_1 | EFF_R }, + { "f32_eq", ARG_2 }, + { "f32_le", ARG_2 }, + { "f32_lt", ARG_2 }, + { "f32_eq_signaling", ARG_2 }, + { "f32_le_quiet", ARG_2 }, + { "f32_lt_quiet", ARG_2 }, + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT64 + { "f64_to_ui32", ARG_1 | ARG_R | ARG_E }, + { "f64_to_ui64", ARG_1 | ARG_R | ARG_E }, + { "f64_to_i32", ARG_1 | ARG_R | ARG_E }, + { "f64_to_i64", ARG_1 | ARG_R | ARG_E }, + { "f64_to_ui32_r_minMag", ARG_1 | ARG_E }, + { "f64_to_ui64_r_minMag", ARG_1 | ARG_E }, + { "f64_to_i32_r_minMag", ARG_1 | ARG_E }, + { "f64_to_i64_r_minMag", ARG_1 | ARG_E }, +#ifdef FLOAT16 + { "f64_to_f16", ARG_1 | EFF_R | EFF_T }, +#endif + { "f64_to_f32", ARG_1 | EFF_R | EFF_T }, +#ifdef EXTFLOAT80 + { "f64_to_extF80", ARG_1 }, +#endif +#ifdef FLOAT128 + { "f64_to_f128", ARG_1 }, +#endif + { "f64_roundToInt", ARG_1 | ARG_R | ARG_E }, + { "f64_add", ARG_2 | EFF_R }, + { "f64_sub", ARG_2 | EFF_R }, + { "f64_mul", ARG_2 | EFF_R | EFF_T }, + { "f64_mulAdd", EFF_R | EFF_T }, + { "f64_div", ARG_2 | EFF_R }, + { "f64_rem", ARG_2 }, + { "f64_sqrt", ARG_1 | EFF_R }, + { "f64_eq", ARG_2 }, + { "f64_le", ARG_2 }, + { "f64_lt", ARG_2 }, + { "f64_eq_signaling", ARG_2 }, + { "f64_le_quiet", ARG_2 }, + { "f64_lt_quiet", ARG_2 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef EXTFLOAT80 + { "extF80_to_ui32", ARG_1 | ARG_R | ARG_E }, + { "extF80_to_ui64", ARG_1 | ARG_R | ARG_E }, + { "extF80_to_i32", ARG_1 | ARG_R | ARG_E }, + { "extF80_to_i64", ARG_1 | ARG_R | ARG_E }, + { "extF80_to_ui32_r_minMag", ARG_1 | ARG_E }, + { "extF80_to_ui64_r_minMag", ARG_1 | ARG_E }, + { "extF80_to_i32_r_minMag", ARG_1 | ARG_E }, + { "extF80_to_i64_r_minMag", ARG_1 | ARG_E }, +#ifdef FLOAT16 + { "extF80_to_f16", ARG_1 | EFF_R | EFF_T }, +#endif + { "extF80_to_f32", ARG_1 | EFF_R | EFF_T }, +#ifdef FLOAT64 + { "extF80_to_f64", ARG_1 | EFF_R | EFF_T }, +#endif +#ifdef FLOAT128 + { "extF80_to_f128", ARG_1 }, +#endif + { "extF80_roundToInt", ARG_1 | ARG_R | ARG_E }, + { "extF80_add", ARG_2 | EFF_P | EFF_R | EFF_T_REDP }, + { "extF80_sub", ARG_2 | EFF_P | EFF_R | EFF_T_REDP }, + { "extF80_mul", ARG_2 | EFF_P | EFF_R | EFF_T | EFF_T_REDP }, + { "extF80_div", ARG_2 | EFF_P | EFF_R | EFF_T_REDP }, + { "extF80_rem", ARG_2 }, + { "extF80_sqrt", ARG_1 | EFF_P | EFF_R }, + { "extF80_eq", ARG_2 }, + { "extF80_le", ARG_2 }, + { "extF80_lt", ARG_2 }, + { "extF80_eq_signaling", ARG_2 }, + { "extF80_le_quiet", ARG_2 }, + { "extF80_lt_quiet", ARG_2 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT128 + { "f128_to_ui32", ARG_1 | ARG_R | ARG_E }, + { "f128_to_ui64", ARG_1 | ARG_R | ARG_E }, + { "f128_to_i32", ARG_1 | ARG_R | ARG_E }, + { "f128_to_i64", ARG_1 | ARG_R | ARG_E }, + { "f128_to_ui32_r_minMag", ARG_1 | ARG_E }, + { "f128_to_ui64_r_minMag", ARG_1 | ARG_E }, + { "f128_to_i32_r_minMag", ARG_1 | ARG_E }, + { "f128_to_i64_r_minMag", ARG_1 | ARG_E }, +#ifdef FLOAT16 + { "f128_to_f16", ARG_1 | EFF_R | EFF_T }, +#endif + { "f128_to_f32", ARG_1 | EFF_R | EFF_T }, +#ifdef FLOAT64 + { "f128_to_f64", ARG_1 | EFF_R | EFF_T }, +#endif +#ifdef EXTFLOAT80 + { "f128_to_extF80", ARG_1 | EFF_R | EFF_T }, +#endif + { "f128_roundToInt", ARG_1 | ARG_R | ARG_E }, + { "f128_add", ARG_2 | EFF_R }, + { "f128_sub", ARG_2 | EFF_R }, + { "f128_mul", ARG_2 | EFF_R | EFF_T }, + { "f128_mulAdd", EFF_R | EFF_T }, + { "f128_div", ARG_2 | EFF_R }, + { "f128_rem", ARG_2 }, + { "f128_sqrt", ARG_1 | EFF_R }, + { "f128_eq", ARG_2 }, + { "f128_le", ARG_2 }, + { "f128_lt", ARG_2 }, + { "f128_eq_signaling", ARG_2 }, + { "f128_le_quiet", ARG_2 }, + { "f128_lt_quiet", ARG_2 }, +#endif +}; + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/functions.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/functions.h new file mode 100644 index 000000000..85eaaf8be --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/functions.h @@ -0,0 +1,324 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include + +/*---------------------------------------------------------------------------- +| Warning: This list must match the contents of "functionInfos.c". +*----------------------------------------------------------------------------*/ +enum { + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 + UI32_TO_F16 = 1, + UI32_TO_F32, +#else + UI32_TO_F32 = 1, +#endif +#ifdef FLOAT64 + UI32_TO_F64, +#endif +#ifdef EXTFLOAT80 + UI32_TO_EXTF80, +#endif +#ifdef FLOAT128 + UI32_TO_F128, +#endif +#ifdef FLOAT16 + UI64_TO_F16, +#endif + UI64_TO_F32, +#ifdef FLOAT64 + UI64_TO_F64, +#endif +#ifdef EXTFLOAT80 + UI64_TO_EXTF80, +#endif +#ifdef FLOAT128 + UI64_TO_F128, +#endif +#ifdef FLOAT16 + I32_TO_F16, +#endif + I32_TO_F32, +#ifdef FLOAT64 + I32_TO_F64, +#endif +#ifdef EXTFLOAT80 + I32_TO_EXTF80, +#endif +#ifdef FLOAT128 + I32_TO_F128, +#endif +#ifdef FLOAT16 + I64_TO_F16, +#endif + I64_TO_F32, +#ifdef FLOAT64 + I64_TO_F64, +#endif +#ifdef EXTFLOAT80 + I64_TO_EXTF80, +#endif +#ifdef FLOAT128 + I64_TO_F128, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 + F16_TO_UI32, + F16_TO_UI64, + F16_TO_I32, + F16_TO_I64, + F16_TO_UI32_R_MINMAG, + F16_TO_UI64_R_MINMAG, + F16_TO_I32_R_MINMAG, + F16_TO_I64_R_MINMAG, + F16_TO_F32, +#ifdef FLOAT64 + F16_TO_F64, +#endif +#ifdef EXTFLOAT80 + F16_TO_EXTF80, +#endif +#ifdef FLOAT128 + F16_TO_F128, +#endif + F16_ROUNDTOINT, + F16_ADD, + F16_SUB, + F16_MUL, + F16_MULADD, + F16_DIV, + F16_REM, + F16_SQRT, + F16_EQ, + F16_LE, + F16_LT, + F16_EQ_SIGNALING, + F16_LE_QUIET, + F16_LT_QUIET, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + F32_TO_UI32, + F32_TO_UI64, + F32_TO_I32, + F32_TO_I64, + F32_TO_UI32_R_MINMAG, + F32_TO_UI64_R_MINMAG, + F32_TO_I32_R_MINMAG, + F32_TO_I64_R_MINMAG, +#ifdef FLOAT16 + F32_TO_F16, +#endif +#ifdef FLOAT64 + F32_TO_F64, +#endif +#ifdef EXTFLOAT80 + F32_TO_EXTF80, +#endif +#ifdef FLOAT128 + F32_TO_F128, +#endif + F32_ROUNDTOINT, + F32_ADD, + F32_SUB, + F32_MUL, + F32_MULADD, + F32_DIV, + F32_REM, + F32_SQRT, + F32_EQ, + F32_LE, + F32_LT, + F32_EQ_SIGNALING, + F32_LE_QUIET, + F32_LT_QUIET, + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT64 + F64_TO_UI32, + F64_TO_UI64, + F64_TO_I32, + F64_TO_I64, + F64_TO_UI32_R_MINMAG, + F64_TO_UI64_R_MINMAG, + F64_TO_I32_R_MINMAG, + F64_TO_I64_R_MINMAG, +#ifdef FLOAT16 + F64_TO_F16, +#endif + F64_TO_F32, +#ifdef EXTFLOAT80 + F64_TO_EXTF80, +#endif +#ifdef FLOAT128 + F64_TO_F128, +#endif + F64_ROUNDTOINT, + F64_ADD, + F64_SUB, + F64_MUL, + F64_MULADD, + F64_DIV, + F64_REM, + F64_SQRT, + F64_EQ, + F64_LE, + F64_LT, + F64_EQ_SIGNALING, + F64_LE_QUIET, + F64_LT_QUIET, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef EXTFLOAT80 + EXTF80_TO_UI32, + EXTF80_TO_UI64, + EXTF80_TO_I32, + EXTF80_TO_I64, + EXTF80_TO_UI32_R_MINMAG, + EXTF80_TO_UI64_R_MINMAG, + EXTF80_TO_I32_R_MINMAG, + EXTF80_TO_I64_R_MINMAG, +#ifdef FLOAT16 + EXTF80_TO_F16, +#endif + EXTF80_TO_F32, +#ifdef FLOAT64 + EXTF80_TO_F64, +#endif +#ifdef FLOAT128 + EXTF80_TO_F128, +#endif + EXTF80_ROUNDTOINT, + EXTF80_ADD, + EXTF80_SUB, + EXTF80_MUL, + EXTF80_DIV, + EXTF80_REM, + EXTF80_SQRT, + EXTF80_EQ, + EXTF80_LE, + EXTF80_LT, + EXTF80_EQ_SIGNALING, + EXTF80_LE_QUIET, + EXTF80_LT_QUIET, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT128 + F128_TO_UI32, + F128_TO_UI64, + F128_TO_I32, + F128_TO_I64, + F128_TO_UI32_R_MINMAG, + F128_TO_UI64_R_MINMAG, + F128_TO_I32_R_MINMAG, + F128_TO_I64_R_MINMAG, +#ifdef FLOAT16 + F128_TO_F16, +#endif + F128_TO_F32, +#ifdef FLOAT64 + F128_TO_F64, +#endif +#ifdef EXTFLOAT80 + F128_TO_EXTF80, +#endif + F128_ROUNDTOINT, + F128_ADD, + F128_SUB, + F128_MUL, + F128_MULADD, + F128_DIV, + F128_REM, + F128_SQRT, + F128_EQ, + F128_LE, + F128_LT, + F128_EQ_SIGNALING, + F128_LE_QUIET, + F128_LT_QUIET, +#endif + NUM_FUNCTIONS +}; + +enum { + ROUND_NEAR_EVEN = 1, + ROUND_MINMAG, + ROUND_MIN, + ROUND_MAX, + ROUND_NEAR_MAXMAG, +#ifdef FLOAT_ROUND_ODD + ROUND_ODD, +#endif + NUM_ROUNDINGMODES +}; +enum { + TININESS_BEFORE_ROUNDING = 1, + TININESS_AFTER_ROUNDING, + NUM_TININESSMODES +}; + +extern const uint_fast8_t roundingModes[NUM_ROUNDINGMODES]; +extern const uint_fast8_t tininessModes[NUM_TININESSMODES]; + +enum { + FUNC_ARG_UNARY = 0x01, + FUNC_ARG_BINARY = 0x02, + FUNC_ARG_ROUNDINGMODE = 0x04, + FUNC_ARG_EXACT = 0x08, + FUNC_EFF_ROUNDINGPRECISION = 0x10, + FUNC_EFF_ROUNDINGMODE = 0x20, + FUNC_EFF_TININESSMODE = 0x40, + FUNC_EFF_TININESSMODE_REDUCEDPREC = 0x80 +}; +struct functionInfo { + const char *namePtr; + unsigned char attribs; +}; +extern const struct functionInfo functionInfos[NUM_FUNCTIONS]; + +struct standardFunctionInfo { + const char *namePtr; + unsigned char functionCode; + char roundingCode, exact; +}; +extern const struct standardFunctionInfo standardFunctionInfos[]; + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/functions_common.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/functions_common.c new file mode 100644 index 000000000..16cf3c72f --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/functions_common.c @@ -0,0 +1,60 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "functions.h" + +const uint_fast8_t roundingModes[NUM_ROUNDINGMODES] = { + 0, + softfloat_round_near_even, + softfloat_round_minMag, + softfloat_round_min, + softfloat_round_max, + softfloat_round_near_maxMag, +#ifdef FLOAT_ROUND_ODD + softfloat_round_odd +#endif +}; + +const uint_fast8_t tininessModes[NUM_TININESSMODES] = { + 0, + softfloat_tininess_beforeRounding, + softfloat_tininess_afterRounding +}; + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases.h new file mode 100644 index 000000000..efea7dd1a --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases.h @@ -0,0 +1,114 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "softfloat.h" + +extern int genCases_level; + +void genCases_setLevel( int ); + +extern uint_fast64_t genCases_total; +extern bool genCases_done; + +void genCases_ui32_a_init( void ); +void genCases_ui32_a_next( void ); +extern uint32_t genCases_ui32_a; + +void genCases_ui64_a_init( void ); +void genCases_ui64_a_next( void ); +extern uint64_t genCases_ui64_a; + +void genCases_i32_a_init( void ); +void genCases_i32_a_next( void ); +extern int32_t genCases_i32_a; + +void genCases_i64_a_init( void ); +void genCases_i64_a_next( void ); +extern int64_t genCases_i64_a; + +#ifdef FLOAT16 +void genCases_f16_a_init( void ); +void genCases_f16_a_next( void ); +void genCases_f16_ab_init( void ); +void genCases_f16_ab_next( void ); +void genCases_f16_abc_init( void ); +void genCases_f16_abc_next( void ); +extern float16_t genCases_f16_a, genCases_f16_b, genCases_f16_c; +#endif + +void genCases_f32_a_init( void ); +void genCases_f32_a_next( void ); +void genCases_f32_ab_init( void ); +void genCases_f32_ab_next( void ); +void genCases_f32_abc_init( void ); +void genCases_f32_abc_next( void ); +extern float32_t genCases_f32_a, genCases_f32_b, genCases_f32_c; + +#ifdef FLOAT64 +void genCases_f64_a_init( void ); +void genCases_f64_a_next( void ); +void genCases_f64_ab_init( void ); +void genCases_f64_ab_next( void ); +void genCases_f64_abc_init( void ); +void genCases_f64_abc_next( void ); +extern float64_t genCases_f64_a, genCases_f64_b, genCases_f64_c; +#endif + +#ifdef EXTFLOAT80 +void genCases_extF80_a_init( void ); +void genCases_extF80_a_next( void ); +void genCases_extF80_ab_init( void ); +void genCases_extF80_ab_next( void ); +void genCases_extF80_abc_init( void ); +void genCases_extF80_abc_next( void ); +extern extFloat80_t genCases_extF80_a, genCases_extF80_b, genCases_extF80_c; +#endif + +#ifdef FLOAT128 +void genCases_f128_a_init( void ); +void genCases_f128_a_next( void ); +void genCases_f128_ab_init( void ); +void genCases_f128_ab_next( void ); +void genCases_f128_abc_init( void ); +void genCases_f128_abc_next( void ); +extern float128_t genCases_f128_a, genCases_f128_b, genCases_f128_c; +#endif + +void genCases_writeTestsTotal( bool ); + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_common.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_common.c new file mode 100644 index 000000000..25e733e45 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_common.c @@ -0,0 +1,58 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "fail.h" +#include "genCases.h" + +int genCases_level = 0; + +void genCases_setLevel( int newLevel ) +{ + + if ( (newLevel < 1) || (2 < newLevel) ) { + fail( "Invalid testing level %d", newLevel ); + } + genCases_level = newLevel; + +} + +uint_fast64_t genCases_total; +bool genCases_done; + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_extF80.c new file mode 100644 index 000000000..97e455777 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_extF80.c @@ -0,0 +1,920 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "softfloat.h" +#include "genCases.h" + +#ifdef EXTFLOAT80 + +struct sequence { + int expNum, term1Num, term2Num; + bool done; +}; + +enum { + extF80NumQIn = 22, + extF80NumQOut = 76, + extF80NumP1 = 4, + extF80NumP2 = 248 +}; +static const uint16_t extF80QIn[extF80NumQIn] = { + 0x0000, /* positive, subnormal */ + 0x0001, /* positive, -16382 */ + 0x3FBF, /* positive, -64 */ + 0x3FFD, /* positive, -2 */ + 0x3FFE, /* positive, -1 */ + 0x3FFF, /* positive, 0 */ + 0x4000, /* positive, 1 */ + 0x4001, /* positive, 2 */ + 0x403F, /* positive, 64 */ + 0x7FFE, /* positive, 16383 */ + 0x7FFF, /* positive, infinity or NaN */ + 0x8000, /* negative, subnormal */ + 0x8001, /* negative, -16382 */ + 0xBFBF, /* negative, -64 */ + 0xBFFD, /* negative, -2 */ + 0xBFFE, /* negative, -1 */ + 0xBFFF, /* negative, 0 */ + 0xC000, /* negative, 1 */ + 0xC001, /* negative, 2 */ + 0xC03F, /* negative, 64 */ + 0xFFFE, /* negative, 16383 */ + 0xFFFF /* negative, infinity or NaN */ +}; +static const uint16_t extF80QOut[extF80NumQOut] = { + 0x0000, /* positive, subnormal */ + 0x0001, /* positive, -16382 */ + 0x0002, /* positive, -16381 */ + 0x3BFE, /* positive, -1025 */ + 0x3BFF, /* positive, -1024 */ + 0x3C00, /* positive, -1023 */ + 0x3C01, /* positive, -1022 */ + 0x3F7E, /* positive, -129 */ + 0x3F7F, /* positive, -128 */ + 0x3F80, /* positive, -127 */ + 0x3F81, /* positive, -126 */ + 0x3FBF, /* positive, -64 */ + 0x3FFB, /* positive, -4 */ + 0x3FFC, /* positive, -3 */ + 0x3FFD, /* positive, -2 */ + 0x3FFE, /* positive, -1 */ + 0x3FFF, /* positive, 0 */ + 0x4000, /* positive, 1 */ + 0x4001, /* positive, 2 */ + 0x4002, /* positive, 3 */ + 0x4003, /* positive, 4 */ + 0x401C, /* positive, 29 */ + 0x401D, /* positive, 30 */ + 0x401E, /* positive, 31 */ + 0x401F, /* positive, 32 */ + 0x403C, /* positive, 61 */ + 0x403D, /* positive, 62 */ + 0x403E, /* positive, 63 */ + 0x403F, /* positive, 64 */ + 0x407E, /* positive, 127 */ + 0x407F, /* positive, 128 */ + 0x4080, /* positive, 129 */ + 0x43FE, /* positive, 1023 */ + 0x43FF, /* positive, 1024 */ + 0x4400, /* positive, 1025 */ + 0x7FFD, /* positive, 16382 */ + 0x7FFE, /* positive, 16383 */ + 0x7FFF, /* positive, infinity or NaN */ + 0x8000, /* negative, subnormal */ + 0x8001, /* negative, -16382 */ + 0x8002, /* negative, -16381 */ + 0xBBFE, /* negative, -1025 */ + 0xBBFF, /* negative, -1024 */ + 0xBC00, /* negative, -1023 */ + 0xBC01, /* negative, -1022 */ + 0xBF7E, /* negative, -129 */ + 0xBF7F, /* negative, -128 */ + 0xBF80, /* negative, -127 */ + 0xBF81, /* negative, -126 */ + 0xBFBF, /* negative, -64 */ + 0xBFFB, /* negative, -4 */ + 0xBFFC, /* negative, -3 */ + 0xBFFD, /* negative, -2 */ + 0xBFFE, /* negative, -1 */ + 0xBFFF, /* negative, 0 */ + 0xC000, /* negative, 1 */ + 0xC001, /* negative, 2 */ + 0xC002, /* negative, 3 */ + 0xC003, /* negative, 4 */ + 0xC01C, /* negative, 29 */ + 0xC01D, /* negative, 30 */ + 0xC01E, /* negative, 31 */ + 0xC01F, /* negative, 32 */ + 0xC03C, /* negative, 61 */ + 0xC03D, /* negative, 62 */ + 0xC03E, /* negative, 63 */ + 0xC03F, /* negative, 64 */ + 0xC07E, /* negative, 127 */ + 0xC07F, /* negative, 128 */ + 0xC080, /* negative, 129 */ + 0xC3FE, /* negative, 1023 */ + 0xC3FF, /* negative, 1024 */ + 0xC400, /* negative, 1025 */ + 0xFFFD, /* negative, 16382 */ + 0xFFFE, /* negative, 16383 */ + 0xFFFF /* negative, infinity or NaN */ +}; +static const uint64_t extF80P1[extF80NumP1] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000001 ), + UINT64_C( 0x7FFFFFFFFFFFFFFF ), + UINT64_C( 0x7FFFFFFFFFFFFFFE ) +}; +static const uint64_t extF80P2[extF80NumP2] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000001 ), + UINT64_C( 0x0000000000000002 ), + UINT64_C( 0x0000000000000004 ), + UINT64_C( 0x0000000000000008 ), + UINT64_C( 0x0000000000000010 ), + UINT64_C( 0x0000000000000020 ), + UINT64_C( 0x0000000000000040 ), + UINT64_C( 0x0000000000000080 ), + UINT64_C( 0x0000000000000100 ), + UINT64_C( 0x0000000000000200 ), + UINT64_C( 0x0000000000000400 ), + UINT64_C( 0x0000000000000800 ), + UINT64_C( 0x0000000000001000 ), + UINT64_C( 0x0000000000002000 ), + UINT64_C( 0x0000000000004000 ), + UINT64_C( 0x0000000000008000 ), + UINT64_C( 0x0000000000010000 ), + UINT64_C( 0x0000000000020000 ), + UINT64_C( 0x0000000000040000 ), + UINT64_C( 0x0000000000080000 ), + UINT64_C( 0x0000000000100000 ), + UINT64_C( 0x0000000000200000 ), + UINT64_C( 0x0000000000400000 ), + UINT64_C( 0x0000000000800000 ), + UINT64_C( 0x0000000001000000 ), + UINT64_C( 0x0000000002000000 ), + UINT64_C( 0x0000000004000000 ), + UINT64_C( 0x0000000008000000 ), + UINT64_C( 0x0000000010000000 ), + UINT64_C( 0x0000000020000000 ), + UINT64_C( 0x0000000040000000 ), + UINT64_C( 0x0000000080000000 ), + UINT64_C( 0x0000000100000000 ), + UINT64_C( 0x0000000200000000 ), + UINT64_C( 0x0000000400000000 ), + UINT64_C( 0x0000000800000000 ), + UINT64_C( 0x0000001000000000 ), + UINT64_C( 0x0000002000000000 ), + UINT64_C( 0x0000004000000000 ), + UINT64_C( 0x0000008000000000 ), + UINT64_C( 0x0000010000000000 ), + UINT64_C( 0x0000020000000000 ), + UINT64_C( 0x0000040000000000 ), + UINT64_C( 0x0000080000000000 ), + UINT64_C( 0x0000100000000000 ), + UINT64_C( 0x0000200000000000 ), + UINT64_C( 0x0000400000000000 ), + UINT64_C( 0x0000800000000000 ), + UINT64_C( 0x0001000000000000 ), + UINT64_C( 0x0002000000000000 ), + UINT64_C( 0x0004000000000000 ), + UINT64_C( 0x0008000000000000 ), + UINT64_C( 0x0010000000000000 ), + UINT64_C( 0x0020000000000000 ), + UINT64_C( 0x0040000000000000 ), + UINT64_C( 0x0080000000000000 ), + UINT64_C( 0x0100000000000000 ), + UINT64_C( 0x0200000000000000 ), + UINT64_C( 0x0400000000000000 ), + UINT64_C( 0x0800000000000000 ), + UINT64_C( 0x1000000000000000 ), + UINT64_C( 0x2000000000000000 ), + UINT64_C( 0x4000000000000000 ), + UINT64_C( 0x6000000000000000 ), + UINT64_C( 0x7000000000000000 ), + UINT64_C( 0x7800000000000000 ), + UINT64_C( 0x7C00000000000000 ), + UINT64_C( 0x7E00000000000000 ), + UINT64_C( 0x7F00000000000000 ), + UINT64_C( 0x7F80000000000000 ), + UINT64_C( 0x7FC0000000000000 ), + UINT64_C( 0x7FE0000000000000 ), + UINT64_C( 0x7FF0000000000000 ), + UINT64_C( 0x7FF8000000000000 ), + UINT64_C( 0x7FFC000000000000 ), + UINT64_C( 0x7FFE000000000000 ), + UINT64_C( 0x7FFF000000000000 ), + UINT64_C( 0x7FFF800000000000 ), + UINT64_C( 0x7FFFC00000000000 ), + UINT64_C( 0x7FFFE00000000000 ), + UINT64_C( 0x7FFFF00000000000 ), + UINT64_C( 0x7FFFF80000000000 ), + UINT64_C( 0x7FFFFC0000000000 ), + UINT64_C( 0x7FFFFE0000000000 ), + UINT64_C( 0x7FFFFF0000000000 ), + UINT64_C( 0x7FFFFF8000000000 ), + UINT64_C( 0x7FFFFFC000000000 ), + UINT64_C( 0x7FFFFFE000000000 ), + UINT64_C( 0x7FFFFFF000000000 ), + UINT64_C( 0x7FFFFFF800000000 ), + UINT64_C( 0x7FFFFFFC00000000 ), + UINT64_C( 0x7FFFFFFE00000000 ), + UINT64_C( 0x7FFFFFFF00000000 ), + UINT64_C( 0x7FFFFFFF80000000 ), + UINT64_C( 0x7FFFFFFFC0000000 ), + UINT64_C( 0x7FFFFFFFE0000000 ), + UINT64_C( 0x7FFFFFFFF0000000 ), + UINT64_C( 0x7FFFFFFFF8000000 ), + UINT64_C( 0x7FFFFFFFFC000000 ), + UINT64_C( 0x7FFFFFFFFE000000 ), + UINT64_C( 0x7FFFFFFFFF000000 ), + UINT64_C( 0x7FFFFFFFFF800000 ), + UINT64_C( 0x7FFFFFFFFFC00000 ), + UINT64_C( 0x7FFFFFFFFFE00000 ), + UINT64_C( 0x7FFFFFFFFFF00000 ), + UINT64_C( 0x7FFFFFFFFFF80000 ), + UINT64_C( 0x7FFFFFFFFFFC0000 ), + UINT64_C( 0x7FFFFFFFFFFE0000 ), + UINT64_C( 0x7FFFFFFFFFFF0000 ), + UINT64_C( 0x7FFFFFFFFFFF8000 ), + UINT64_C( 0x7FFFFFFFFFFFC000 ), + UINT64_C( 0x7FFFFFFFFFFFE000 ), + UINT64_C( 0x7FFFFFFFFFFFF000 ), + UINT64_C( 0x7FFFFFFFFFFFF800 ), + UINT64_C( 0x7FFFFFFFFFFFFC00 ), + UINT64_C( 0x7FFFFFFFFFFFFE00 ), + UINT64_C( 0x7FFFFFFFFFFFFF00 ), + UINT64_C( 0x7FFFFFFFFFFFFF80 ), + UINT64_C( 0x7FFFFFFFFFFFFFC0 ), + UINT64_C( 0x7FFFFFFFFFFFFFE0 ), + UINT64_C( 0x7FFFFFFFFFFFFFF0 ), + UINT64_C( 0x7FFFFFFFFFFFFFF8 ), + UINT64_C( 0x7FFFFFFFFFFFFFFC ), + UINT64_C( 0x7FFFFFFFFFFFFFFE ), + UINT64_C( 0x7FFFFFFFFFFFFFFF ), + UINT64_C( 0x7FFFFFFFFFFFFFFD ), + UINT64_C( 0x7FFFFFFFFFFFFFFB ), + UINT64_C( 0x7FFFFFFFFFFFFFF7 ), + UINT64_C( 0x7FFFFFFFFFFFFFEF ), + UINT64_C( 0x7FFFFFFFFFFFFFDF ), + UINT64_C( 0x7FFFFFFFFFFFFFBF ), + UINT64_C( 0x7FFFFFFFFFFFFF7F ), + UINT64_C( 0x7FFFFFFFFFFFFEFF ), + UINT64_C( 0x7FFFFFFFFFFFFDFF ), + UINT64_C( 0x7FFFFFFFFFFFFBFF ), + UINT64_C( 0x7FFFFFFFFFFFF7FF ), + UINT64_C( 0x7FFFFFFFFFFFEFFF ), + UINT64_C( 0x7FFFFFFFFFFFDFFF ), + UINT64_C( 0x7FFFFFFFFFFFBFFF ), + UINT64_C( 0x7FFFFFFFFFFF7FFF ), + UINT64_C( 0x7FFFFFFFFFFEFFFF ), + UINT64_C( 0x7FFFFFFFFFFDFFFF ), + UINT64_C( 0x7FFFFFFFFFFBFFFF ), + UINT64_C( 0x7FFFFFFFFFF7FFFF ), + UINT64_C( 0x7FFFFFFFFFEFFFFF ), + UINT64_C( 0x7FFFFFFFFFDFFFFF ), + UINT64_C( 0x7FFFFFFFFFBFFFFF ), + UINT64_C( 0x7FFFFFFFFF7FFFFF ), + UINT64_C( 0x7FFFFFFFFEFFFFFF ), + UINT64_C( 0x7FFFFFFFFDFFFFFF ), + UINT64_C( 0x7FFFFFFFFBFFFFFF ), + UINT64_C( 0x7FFFFFFFF7FFFFFF ), + UINT64_C( 0x7FFFFFFFEFFFFFFF ), + UINT64_C( 0x7FFFFFFFDFFFFFFF ), + UINT64_C( 0x7FFFFFFFBFFFFFFF ), + UINT64_C( 0x7FFFFFFF7FFFFFFF ), + UINT64_C( 0x7FFFFFFEFFFFFFFF ), + UINT64_C( 0x7FFFFFFDFFFFFFFF ), + UINT64_C( 0x7FFFFFFBFFFFFFFF ), + UINT64_C( 0x7FFFFFF7FFFFFFFF ), + UINT64_C( 0x7FFFFFEFFFFFFFFF ), + UINT64_C( 0x7FFFFFDFFFFFFFFF ), + UINT64_C( 0x7FFFFFBFFFFFFFFF ), + UINT64_C( 0x7FFFFF7FFFFFFFFF ), + UINT64_C( 0x7FFFFEFFFFFFFFFF ), + UINT64_C( 0x7FFFFDFFFFFFFFFF ), + UINT64_C( 0x7FFFFBFFFFFFFFFF ), + UINT64_C( 0x7FFFF7FFFFFFFFFF ), + UINT64_C( 0x7FFFEFFFFFFFFFFF ), + UINT64_C( 0x7FFFDFFFFFFFFFFF ), + UINT64_C( 0x7FFFBFFFFFFFFFFF ), + UINT64_C( 0x7FFF7FFFFFFFFFFF ), + UINT64_C( 0x7FFEFFFFFFFFFFFF ), + UINT64_C( 0x7FFDFFFFFFFFFFFF ), + UINT64_C( 0x7FFBFFFFFFFFFFFF ), + UINT64_C( 0x7FF7FFFFFFFFFFFF ), + UINT64_C( 0x7FEFFFFFFFFFFFFF ), + UINT64_C( 0x7FDFFFFFFFFFFFFF ), + UINT64_C( 0x7FBFFFFFFFFFFFFF ), + UINT64_C( 0x7F7FFFFFFFFFFFFF ), + UINT64_C( 0x7EFFFFFFFFFFFFFF ), + UINT64_C( 0x7DFFFFFFFFFFFFFF ), + UINT64_C( 0x7BFFFFFFFFFFFFFF ), + UINT64_C( 0x77FFFFFFFFFFFFFF ), + UINT64_C( 0x6FFFFFFFFFFFFFFF ), + UINT64_C( 0x5FFFFFFFFFFFFFFF ), + UINT64_C( 0x3FFFFFFFFFFFFFFF ), + UINT64_C( 0x1FFFFFFFFFFFFFFF ), + UINT64_C( 0x0FFFFFFFFFFFFFFF ), + UINT64_C( 0x07FFFFFFFFFFFFFF ), + UINT64_C( 0x03FFFFFFFFFFFFFF ), + UINT64_C( 0x01FFFFFFFFFFFFFF ), + UINT64_C( 0x00FFFFFFFFFFFFFF ), + UINT64_C( 0x007FFFFFFFFFFFFF ), + UINT64_C( 0x003FFFFFFFFFFFFF ), + UINT64_C( 0x001FFFFFFFFFFFFF ), + UINT64_C( 0x000FFFFFFFFFFFFF ), + UINT64_C( 0x0007FFFFFFFFFFFF ), + UINT64_C( 0x0003FFFFFFFFFFFF ), + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0x0000FFFFFFFFFFFF ), + UINT64_C( 0x00007FFFFFFFFFFF ), + UINT64_C( 0x00003FFFFFFFFFFF ), + UINT64_C( 0x00001FFFFFFFFFFF ), + UINT64_C( 0x00000FFFFFFFFFFF ), + UINT64_C( 0x000007FFFFFFFFFF ), + UINT64_C( 0x000003FFFFFFFFFF ), + UINT64_C( 0x000001FFFFFFFFFF ), + UINT64_C( 0x000000FFFFFFFFFF ), + UINT64_C( 0x0000007FFFFFFFFF ), + UINT64_C( 0x0000003FFFFFFFFF ), + UINT64_C( 0x0000001FFFFFFFFF ), + UINT64_C( 0x0000000FFFFFFFFF ), + UINT64_C( 0x00000007FFFFFFFF ), + UINT64_C( 0x00000003FFFFFFFF ), + UINT64_C( 0x00000001FFFFFFFF ), + UINT64_C( 0x00000000FFFFFFFF ), + UINT64_C( 0x000000007FFFFFFF ), + UINT64_C( 0x000000003FFFFFFF ), + UINT64_C( 0x000000001FFFFFFF ), + UINT64_C( 0x000000000FFFFFFF ), + UINT64_C( 0x0000000007FFFFFF ), + UINT64_C( 0x0000000003FFFFFF ), + UINT64_C( 0x0000000001FFFFFF ), + UINT64_C( 0x0000000000FFFFFF ), + UINT64_C( 0x00000000007FFFFF ), + UINT64_C( 0x00000000003FFFFF ), + UINT64_C( 0x00000000001FFFFF ), + UINT64_C( 0x00000000000FFFFF ), + UINT64_C( 0x000000000007FFFF ), + UINT64_C( 0x000000000003FFFF ), + UINT64_C( 0x000000000001FFFF ), + UINT64_C( 0x000000000000FFFF ), + UINT64_C( 0x0000000000007FFF ), + UINT64_C( 0x0000000000003FFF ), + UINT64_C( 0x0000000000001FFF ), + UINT64_C( 0x0000000000000FFF ), + UINT64_C( 0x00000000000007FF ), + UINT64_C( 0x00000000000003FF ), + UINT64_C( 0x00000000000001FF ), + UINT64_C( 0x00000000000000FF ), + UINT64_C( 0x000000000000007F ), + UINT64_C( 0x000000000000003F ), + UINT64_C( 0x000000000000001F ), + UINT64_C( 0x000000000000000F ), + UINT64_C( 0x0000000000000007 ), + UINT64_C( 0x0000000000000003 ) +}; + +static const uint_fast32_t extF80NumQInP1 = extF80NumQIn * extF80NumP1; +static const uint_fast32_t extF80NumQOutP1 = extF80NumQOut * extF80NumP1; + +static void extF80NextQInP1( struct sequence *sequencePtr, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + int expNum, sigNum; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZ64 = extF80QIn[expNum]; + uiZ0 = extF80P1[sigNum]; + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + ++sigNum; + if ( extF80NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( extF80NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static + void extF80NextQOutP1( struct sequence *sequencePtr, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + int expNum, sigNum; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZ64 = extF80QOut[expNum]; + uiZ0 = extF80P1[sigNum]; + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + ++sigNum; + if ( extF80NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( extF80NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static const uint_fast32_t extF80NumQInP2 = extF80NumQIn * extF80NumP2; +static const uint_fast32_t extF80NumQOutP2 = extF80NumQOut * extF80NumP2; + +static void extF80NextQInP2( struct sequence *sequencePtr, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + int expNum, sigNum; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZ64 = extF80QIn[expNum]; + uiZ0 = extF80P2[sigNum]; + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + ++sigNum; + if ( extF80NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( extF80NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static + void extF80NextQOutP2( struct sequence *sequencePtr, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + int expNum, sigNum; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZ64 = extF80QOut[expNum]; + uiZ0 = extF80P2[sigNum]; + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + ++sigNum; + if ( extF80NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( extF80NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static void extF80RandomQOutP3( extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + uiZ64 = extF80QOut[randomN_ui8( extF80NumQOut )]; + uiZ0 = + (extF80P2[randomN_ui8( extF80NumP2 )] + + extF80P2[randomN_ui8( extF80NumP2 )]) + & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + +} + +static void extF80RandomQOutPInf( extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + uiZ64 = extF80QOut[randomN_ui8( extF80NumQOut )]; + uiZ0 = random_ui64() & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + +} + +enum { extF80NumQInfWeightMasks = 14 }; +static const uint16_t extF80QInfWeightMasks[extF80NumQInfWeightMasks] = { + 0xFFFF, + 0xFFFF, + 0xBFFF, + 0x9FFF, + 0x87FF, + 0x87FF, + 0x83FF, + 0x81FF, + 0x80FF, + 0x807F, + 0x803F, + 0x801F, + 0x800F, + 0x8007 +}; +static const uint16_t extF80QInfWeightOffsets[extF80NumQInfWeightMasks] = { + 0x0000, + 0x0000, + 0x2000, + 0x3000, + 0x3800, + 0x3C00, + 0x3E00, + 0x3F00, + 0x3F80, + 0x3FC0, + 0x3FE0, + 0x3FF0, + 0x3FF8, + 0x3FFC +}; + +static void extF80RandomQInfP3( extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + int weightMaskNum; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + weightMaskNum = randomN_ui8( extF80NumQInfWeightMasks ); + uiZ64 = + (random_ui16() & extF80QInfWeightMasks[weightMaskNum]) + + extF80QInfWeightOffsets[weightMaskNum]; + uiZ0 = + (extF80P2[randomN_ui8( extF80NumP2 )] + + extF80P2[randomN_ui8( extF80NumP2 )]) + & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + +} + +static void extF80RandomQInfPInf( extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + int weightMaskNum; + uint_fast16_t uiZ64; + uint_fast64_t uiZ0; + + zSPtr = (struct extFloat80M *) zPtr; + weightMaskNum = randomN_ui8( extF80NumQInfWeightMasks ); + uiZ64 = + (random_ui16() & extF80QInfWeightMasks[weightMaskNum]) + + extF80QInfWeightOffsets[weightMaskNum]; + uiZ0 = random_ui64() & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( uiZ64 & 0x7FFF ) uiZ0 |= UINT64_C( 0x8000000000000000 ); + zSPtr->signExp = uiZ64; + zSPtr->signif = uiZ0; + +} + +static void extF80Random( extFloat80_t *zPtr ) +{ + + switch ( random_ui8() & 7 ) { + case 0: + case 1: + case 2: + extF80RandomQOutP3( zPtr ); + break; + case 3: + extF80RandomQOutPInf( zPtr ); + break; + case 4: + case 5: + case 6: + extF80RandomQInfP3( zPtr ); + break; + case 7: + extF80RandomQInfPInf( zPtr ); + break; + } + +} + +static struct sequence sequenceA, sequenceB, sequenceC; +static extFloat80_t currentA, currentB, currentC; +static int subcase; + +extFloat80_t genCases_extF80_a, genCases_extF80_b, genCases_extF80_c; + +void genCases_extF80_a_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = + (genCases_level == 1) ? 3 * extF80NumQOutP1 : 2 * extF80NumQOutP2; + genCases_done = false; + +} + +void genCases_extF80_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + case 1: + extF80Random( &genCases_extF80_a ); + break; + case 2: + extF80NextQOutP1( &sequenceA, &genCases_extF80_a ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + extF80Random( &genCases_extF80_a ); + break; + case 1: + extF80NextQOutP2( &sequenceA, &genCases_extF80_a ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_extF80_ab_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 6 * extF80NumQInP1 * extF80NumQInP1; + extF80NextQInP1( &sequenceA, ¤tA ); + } else { + genCases_total = 2 * extF80NumQInP2 * extF80NumQInP2; + extF80NextQInP2( &sequenceA, ¤tA ); + } + genCases_done = false; + +} + +void genCases_extF80_ab_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceB.done ) { + sequenceB.done = false; + extF80NextQInP1( &sequenceA, ¤tA ); + } + extF80NextQInP1( &sequenceB, ¤tB ); + case 2: + case 4: + extF80Random( &genCases_extF80_a ); + extF80Random( &genCases_extF80_b ); + break; + case 1: + genCases_extF80_a = currentA; + extF80Random( &genCases_extF80_b ); + break; + case 3: + extF80Random( &genCases_extF80_a ); + genCases_extF80_b = currentB; + break; + case 5: + genCases_extF80_a = currentA; + genCases_extF80_b = currentB; + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + extF80Random( &genCases_extF80_a ); + extF80Random( &genCases_extF80_b ); + break; + case 1: + if ( sequenceB.done ) { + sequenceB.done = false; + extF80NextQInP2( &sequenceA, ¤tA ); + } + genCases_extF80_a = currentA; + extF80NextQInP2( &sequenceB, &genCases_extF80_b ); + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_extF80_abc_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + sequenceC.expNum = 0; + sequenceC.term1Num = 0; + sequenceC.term2Num = 0; + sequenceC.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 9 * extF80NumQInP1 * extF80NumQInP1 * extF80NumQInP1; + extF80NextQInP1( &sequenceA, ¤tA ); + extF80NextQInP1( &sequenceB, ¤tB ); + } else { + genCases_total = 2 * extF80NumQInP2 * extF80NumQInP2 * extF80NumQInP2; + extF80NextQInP2( &sequenceA, ¤tA ); + extF80NextQInP2( &sequenceB, ¤tB ); + } + genCases_done = false; + +} + +void genCases_extF80_abc_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + extF80NextQInP1( &sequenceA, ¤tA ); + } + extF80NextQInP1( &sequenceB, ¤tB ); + } + extF80NextQInP1( &sequenceC, ¤tC ); + extF80Random( &genCases_extF80_a ); + extF80Random( &genCases_extF80_b ); + genCases_extF80_c = currentC; + break; + case 1: + genCases_extF80_a = currentA; + genCases_extF80_b = currentB; + extF80Random( &genCases_extF80_c ); + break; + case 2: + extF80Random( &genCases_extF80_a ); + extF80Random( &genCases_extF80_b ); + extF80Random( &genCases_extF80_c ); + break; + case 3: + extF80Random( &genCases_extF80_a ); + genCases_extF80_b = currentB; + genCases_extF80_c = currentC; + break; + case 4: + genCases_extF80_a = currentA; + extF80Random( &genCases_extF80_b ); + extF80Random( &genCases_extF80_c ); + break; + case 5: + extF80Random( &genCases_extF80_a ); + genCases_extF80_b = currentB; + extF80Random( &genCases_extF80_c ); + break; + case 6: + genCases_extF80_a = currentA; + extF80Random( &genCases_extF80_b ); + genCases_extF80_c = currentC; + break; + case 7: + extF80Random( &genCases_extF80_a ); + extF80Random( &genCases_extF80_b ); + extF80Random( &genCases_extF80_c ); + break; + case 8: + genCases_extF80_a = currentA; + genCases_extF80_b = currentB; + genCases_extF80_c = currentC; + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + extF80Random( &genCases_extF80_a ); + extF80Random( &genCases_extF80_b ); + extF80Random( &genCases_extF80_c ); + break; + case 1: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + extF80NextQInP2( &sequenceA, ¤tA ); + } + extF80NextQInP2( &sequenceB, ¤tB ); + } + genCases_extF80_a = currentA; + genCases_extF80_b = currentB; + extF80NextQInP2( &sequenceC, &genCases_extF80_c ); + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f128.c new file mode 100644 index 000000000..e20c7a17f --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f128.c @@ -0,0 +1,1090 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "uint128.h" +#include "random.h" +#include "softfloat.h" +#include "genCases.h" + +#ifdef FLOAT128 + +struct sequence { + int expNum, term1Num, term2Num; + bool done; +}; + +enum { + f128NumQIn = 22, + f128NumQOut = 78, + f128NumP1 = 4, + f128NumP2 = 443 +}; +static const uint64_t f128QIn[f128NumQIn] = { + UINT64_C( 0x0000000000000000 ), /* positive, subnormal */ + UINT64_C( 0x0001000000000000 ), /* positive, -16382 */ + UINT64_C( 0x3F8E000000000000 ), /* positive, -113 */ + UINT64_C( 0x3FFD000000000000 ), /* positive, -2 */ + UINT64_C( 0x3FFE000000000000 ), /* positive, -1 */ + UINT64_C( 0x3FFF000000000000 ), /* positive, 0 */ + UINT64_C( 0x4000000000000000 ), /* positive, 1 */ + UINT64_C( 0x4001000000000000 ), /* positive, 2 */ + UINT64_C( 0x4070000000000000 ), /* positive, 113 */ + UINT64_C( 0x7FFE000000000000 ), /* positive, 16383 */ + UINT64_C( 0x7FFF000000000000 ), /* positive, infinity or NaN */ + UINT64_C( 0x8000000000000000 ), /* negative, subnormal */ + UINT64_C( 0x8001000000000000 ), /* negative, -16382 */ + UINT64_C( 0xBF8E000000000000 ), /* negative, -113 */ + UINT64_C( 0xBFFD000000000000 ), /* negative, -2 */ + UINT64_C( 0xBFFE000000000000 ), /* negative, -1 */ + UINT64_C( 0xBFFF000000000000 ), /* negative, 0 */ + UINT64_C( 0xC000000000000000 ), /* negative, 1 */ + UINT64_C( 0xC001000000000000 ), /* negative, 2 */ + UINT64_C( 0xC070000000000000 ), /* negative, 113 */ + UINT64_C( 0xFFFE000000000000 ), /* negative, 16383 */ + UINT64_C( 0xFFFF000000000000 ) /* negative, infinity or NaN */ +}; +static const uint64_t f128QOut[f128NumQOut] = { + UINT64_C( 0x0000000000000000 ), /* positive, subnormal */ + UINT64_C( 0x0001000000000000 ), /* positive, -16382 */ + UINT64_C( 0x0002000000000000 ), /* positive, -16381 */ + UINT64_C( 0x3BFE000000000000 ), /* positive, -1025 */ + UINT64_C( 0x3BFF000000000000 ), /* positive, -1024 */ + UINT64_C( 0x3C00000000000000 ), /* positive, -1023 */ + UINT64_C( 0x3C01000000000000 ), /* positive, -1022 */ + UINT64_C( 0x3F7E000000000000 ), /* positive, -129 */ + UINT64_C( 0x3F7F000000000000 ), /* positive, -128 */ + UINT64_C( 0x3F80000000000000 ), /* positive, -127 */ + UINT64_C( 0x3F81000000000000 ), /* positive, -126 */ + UINT64_C( 0x3F8E000000000000 ), /* positive, -113 */ + UINT64_C( 0x3FFB000000000000 ), /* positive, -4 */ + UINT64_C( 0x3FFC000000000000 ), /* positive, -3 */ + UINT64_C( 0x3FFD000000000000 ), /* positive, -2 */ + UINT64_C( 0x3FFE000000000000 ), /* positive, -1 */ + UINT64_C( 0x3FFF000000000000 ), /* positive, 0 */ + UINT64_C( 0x4000000000000000 ), /* positive, 1 */ + UINT64_C( 0x4001000000000000 ), /* positive, 2 */ + UINT64_C( 0x4002000000000000 ), /* positive, 3 */ + UINT64_C( 0x4003000000000000 ), /* positive, 4 */ + UINT64_C( 0x401C000000000000 ), /* positive, 29 */ + UINT64_C( 0x401D000000000000 ), /* positive, 30 */ + UINT64_C( 0x401E000000000000 ), /* positive, 31 */ + UINT64_C( 0x401F000000000000 ), /* positive, 32 */ + UINT64_C( 0x403C000000000000 ), /* positive, 61 */ + UINT64_C( 0x403D000000000000 ), /* positive, 62 */ + UINT64_C( 0x403E000000000000 ), /* positive, 63 */ + UINT64_C( 0x403F000000000000 ), /* positive, 64 */ + UINT64_C( 0x4070000000000000 ), /* positive, 113 */ + UINT64_C( 0x407E000000000000 ), /* positive, 127 */ + UINT64_C( 0x407F000000000000 ), /* positive, 128 */ + UINT64_C( 0x4080000000000000 ), /* positive, 129 */ + UINT64_C( 0x43FE000000000000 ), /* positive, 1023 */ + UINT64_C( 0x43FF000000000000 ), /* positive, 1024 */ + UINT64_C( 0x4400000000000000 ), /* positive, 1025 */ + UINT64_C( 0x7FFD000000000000 ), /* positive, 16382 */ + UINT64_C( 0x7FFE000000000000 ), /* positive, 16383 */ + UINT64_C( 0x7FFF000000000000 ), /* positive, infinity or NaN */ + UINT64_C( 0x8000000000000000 ), /* negative, subnormal */ + UINT64_C( 0x8001000000000000 ), /* negative, -16382 */ + UINT64_C( 0x8002000000000000 ), /* negative, -16381 */ + UINT64_C( 0xBBFE000000000000 ), /* negative, -1025 */ + UINT64_C( 0xBBFF000000000000 ), /* negative, -1024 */ + UINT64_C( 0xBC00000000000000 ), /* negative, -1023 */ + UINT64_C( 0xBC01000000000000 ), /* negative, -1022 */ + UINT64_C( 0xBF7E000000000000 ), /* negative, -129 */ + UINT64_C( 0xBF7F000000000000 ), /* negative, -128 */ + UINT64_C( 0xBF80000000000000 ), /* negative, -127 */ + UINT64_C( 0xBF81000000000000 ), /* negative, -126 */ + UINT64_C( 0xBF8E000000000000 ), /* negative, -113 */ + UINT64_C( 0xBFFB000000000000 ), /* negative, -4 */ + UINT64_C( 0xBFFC000000000000 ), /* negative, -3 */ + UINT64_C( 0xBFFD000000000000 ), /* negative, -2 */ + UINT64_C( 0xBFFE000000000000 ), /* negative, -1 */ + UINT64_C( 0xBFFF000000000000 ), /* negative, 0 */ + UINT64_C( 0xC000000000000000 ), /* negative, 1 */ + UINT64_C( 0xC001000000000000 ), /* negative, 2 */ + UINT64_C( 0xC002000000000000 ), /* negative, 3 */ + UINT64_C( 0xC003000000000000 ), /* negative, 4 */ + UINT64_C( 0xC01C000000000000 ), /* negative, 29 */ + UINT64_C( 0xC01D000000000000 ), /* negative, 30 */ + UINT64_C( 0xC01E000000000000 ), /* negative, 31 */ + UINT64_C( 0xC01F000000000000 ), /* negative, 32 */ + UINT64_C( 0xC03C000000000000 ), /* negative, 61 */ + UINT64_C( 0xC03D000000000000 ), /* negative, 62 */ + UINT64_C( 0xC03E000000000000 ), /* negative, 63 */ + UINT64_C( 0xC03F000000000000 ), /* negative, 64 */ + UINT64_C( 0xC070000000000000 ), /* negative, 113 */ + UINT64_C( 0xC07E000000000000 ), /* negative, 127 */ + UINT64_C( 0xC07F000000000000 ), /* negative, 128 */ + UINT64_C( 0xC080000000000000 ), /* negative, 129 */ + UINT64_C( 0xC3FE000000000000 ), /* negative, 1023 */ + UINT64_C( 0xC3FF000000000000 ), /* negative, 1024 */ + UINT64_C( 0xC400000000000000 ), /* negative, 1025 */ + UINT64_C( 0xFFFD000000000000 ), /* negative, 16382 */ + UINT64_C( 0xFFFE000000000000 ), /* negative, 16383 */ + UINT64_C( 0xFFFF000000000000 ) /* negative, infinity or NaN */ +}; +static const struct { uint64_t v64, v0; } f128P1[f128NumP1] = { + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000001 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFE ) } +}; +static const struct { uint64_t v64, v0; } f128P2[f128NumP2] = { + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000001 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000002 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000004 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000008 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000010 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000020 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000040 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000080 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000100 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000200 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000400 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000800 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000001000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000002000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000004000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000008000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000010000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000020000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000040000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000080000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000100000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000200000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000400000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000800000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000001000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000002000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000004000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000008000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000010000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000020000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000040000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000080000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000100000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000200000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000400000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000800000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000001000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000002000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000004000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000008000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000010000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000020000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000040000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000080000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000100000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000200000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000400000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000800000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0001000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0002000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0004000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0008000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0010000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0020000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0040000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0080000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0100000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0200000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0400000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0800000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x1000000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x2000000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x4000000000000000 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x8000000000000000 ) }, + { UINT64_C( 0x0000000000000001 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000002 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000004 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000008 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000010 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000020 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000040 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000080 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000100 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000200 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000400 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000000800 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000001000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000002000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000004000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000008000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000010000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000020000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000040000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000080000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000100000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000200000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000400000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000000800000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000001000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000002000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000004000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000008000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000010000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000020000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000040000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000080000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000100000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000200000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000400000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000000800000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000001000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000002000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000004000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000008000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000010000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000020000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000040000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000080000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000100000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000200000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000400000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000800000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000C00000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000E00000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000F00000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000F80000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FC0000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FE0000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FF0000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FF8000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFC000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFE000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFF000000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFF800000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFC00000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFE00000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFF00000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFF80000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFC0000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFE0000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFF0000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFF8000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFC000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFE000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFF000000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFF800000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFC00000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFE00000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFF00000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFF80000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFC0000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFE0000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFF0000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFF8000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFC000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFE000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFF000 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFF800 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFC00 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFE00 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFF00 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFF80 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFC0 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFE0 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFF0 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFF8 ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFC ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFE ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0x0000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0x8000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xC000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xE000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xF000000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xF800000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFC00000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFE00000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFF00000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFF80000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFC0000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFE0000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFF0000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFF8000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFC000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFE000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFF000000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFF800000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFC00000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFE00000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFF00000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFF80000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFC0000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFE0000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFF0000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFF8000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFC000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFE000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFF000000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFF800000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFC00000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFE00000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFF00000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFF80000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFC0000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFE0000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFF0000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFF8000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFC000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFE000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFF000000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFF800000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFC00000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFE00000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFF00000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFF80000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFC0000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFE0000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFF0000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFF8000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFC000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFE000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFF000 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFF800 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFC00 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFE00 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFF00 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFF80 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFC0 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFE0 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFF0 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFF8 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFC ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFE ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFD ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFB ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFF7 ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFEF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFDF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFBF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFF7F ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFEFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFDFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFBFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFF7FF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFEFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFDFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFBFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFF7FFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFEFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFDFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFBFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFF7FFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFEFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFDFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFBFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFF7FFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFEFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFDFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFBFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFF7FFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFEFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFDFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFBFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFF7FFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFEFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFDFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFBFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFF7FFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFEFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFDFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFFBFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFF7FFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFEFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFDFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFFBFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFF7FFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFEFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFDFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFFBFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFF7FFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFEFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFDFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFFBFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFF7FFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFEFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFDFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFFBFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFF7FFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFEFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFDFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xFBFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xF7FFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xEFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xDFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0xBFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFF ), UINT64_C( 0x7FFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFD ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFFB ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFF7 ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFEF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFDF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFFBF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFF7F ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFEFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFDFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFFBFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFF7FF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFEFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFDFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFFBFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFF7FFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFEFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFDFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFFBFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFF7FFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFEFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFDFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFFBFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFF7FFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFEFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFDFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFFBFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFF7FFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFEFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFDFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFFBFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFF7FFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFEFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFDFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFFBFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFF7FFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFEFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFDFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FFBFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FF7FFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FEFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FDFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000FBFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000F7FFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000EFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000DFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000BFFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00007FFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00003FFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00001FFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000FFFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000007FFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000003FFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000001FFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000FFFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000007FFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000003FFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000001FFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000FFFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000007FFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000003FFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000001FFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000FFFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000007FFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000003FFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000001FFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000FFFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000007FFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000003FFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000001FFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000FFFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000007FFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000003FFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000001FFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000000FFFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000007FFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000003FFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000001FFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000000FFFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000007FFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000003FFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000001FFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000FFF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000000007FF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000000003FF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000000001FF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x00000000000000FF ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000000007F ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000000003F ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000000001F ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x000000000000000F ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000007 ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000003 ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000001 ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0xFFFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x7FFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x3FFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x1FFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0FFFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x07FFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x03FFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x01FFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00FFFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x007FFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x003FFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x001FFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000FFFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0007FFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0003FFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0001FFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000FFFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00007FFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00003FFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00001FFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000FFFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000007FFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000003FFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000001FFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000FFFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000007FFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000003FFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000001FFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000FFFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000007FFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000003FFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000001FFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000FFFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000007FFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000003FFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000001FFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000FFFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000007FFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000003FFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000001FFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000FFFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000007FFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000003FFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000001FFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000000FFFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000007FFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000003FFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000001FFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000000FFFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000007FFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000003FFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000001FFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000FFF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000000007FF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000000003FF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000000001FF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x00000000000000FF ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000000007F ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000000003F ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000000001F ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x000000000000000F ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000007 ) }, + { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000003 ) } +}; + +static const uint_fast64_t f128NumQInP1 = f128NumQIn * f128NumP1; +static const uint_fast64_t f128NumQOutP1 = f128NumQOut * f128NumP1; + +static void f128NextQInP1( struct sequence *sequencePtr, float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + int expNum, sigNum; + + uiZPtr = (struct uint128 *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZPtr->v64 = f128QIn[expNum] | f128P1[sigNum].v64; + uiZPtr->v0 = f128P1[sigNum].v0; + ++sigNum; + if ( f128NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f128NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static void f128NextQOutP1( struct sequence *sequencePtr, float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + int expNum, sigNum; + + uiZPtr = (struct uint128 *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZPtr->v64 = f128QOut[expNum] | f128P1[sigNum].v64; + uiZPtr->v0 = f128P1[sigNum].v0; + ++sigNum; + if ( f128NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f128NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static const uint_fast64_t f128NumQInP2 = f128NumQIn * f128NumP2; +static const uint_fast64_t f128NumQOutP2 = f128NumQOut * f128NumP2; + +static void f128NextQInP2( struct sequence *sequencePtr, float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + int expNum, sigNum; + + uiZPtr = (struct uint128 *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZPtr->v64 = f128QIn[expNum] | f128P2[sigNum].v64; + uiZPtr->v0 = f128P2[sigNum].v0; + ++sigNum; + if ( f128NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f128NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static void f128NextQOutP2( struct sequence *sequencePtr, float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + int expNum, sigNum; + + uiZPtr = (struct uint128 *) zPtr; + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uiZPtr->v64 = f128QOut[expNum] | f128P2[sigNum].v64; + uiZPtr->v0 = f128P2[sigNum].v0; + ++sigNum; + if ( f128NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f128NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + +} + +static void f128RandomQOutP3( float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + int sigNum1, sigNum2; + uint_fast64_t sig1_0; + + uiZPtr = (struct uint128 *) zPtr; + sigNum1 = randomN_ui16( f128NumP2 ); + sigNum2 = randomN_ui16( f128NumP2 ); + sig1_0 = f128P2[sigNum1].v0; + uiZPtr->v0 = sig1_0 + f128P2[sigNum2].v0; + uiZPtr->v64 = + f128QOut[randomN_ui8( f128NumQOut )] + | ((f128P2[sigNum1].v64 + f128P2[sigNum2].v64 + (uiZPtr->v0 < sig1_0)) + & UINT64_C( 0x0000FFFFFFFFFFFF )); + +} + +static void f128RandomQOutPInf( float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + + uiZPtr = (struct uint128 *) zPtr; + uiZPtr->v64 = + f128QOut[randomN_ui8( f128NumQOut )] + | (random_ui64() & UINT64_C( 0x0000FFFFFFFFFFFF )); + uiZPtr->v0 = random_ui64(); + +} + +enum { f128NumQInfWeightMasks = 14 }; +static const uint64_t f128QInfWeightMasks[f128NumQInfWeightMasks] = { + UINT64_C( 0xFFFF000000000000 ), + UINT64_C( 0xFFFF000000000000 ), + UINT64_C( 0xBFFF000000000000 ), + UINT64_C( 0x9FFF000000000000 ), + UINT64_C( 0x87FF000000000000 ), + UINT64_C( 0x87FF000000000000 ), + UINT64_C( 0x83FF000000000000 ), + UINT64_C( 0x81FF000000000000 ), + UINT64_C( 0x80FF000000000000 ), + UINT64_C( 0x807F000000000000 ), + UINT64_C( 0x803F000000000000 ), + UINT64_C( 0x801F000000000000 ), + UINT64_C( 0x800F000000000000 ), + UINT64_C( 0x8007000000000000 ) +}; +static const uint64_t f128QInfWeightOffsets[f128NumQInfWeightMasks] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x2000000000000000 ), + UINT64_C( 0x3000000000000000 ), + UINT64_C( 0x3800000000000000 ), + UINT64_C( 0x3C00000000000000 ), + UINT64_C( 0x3E00000000000000 ), + UINT64_C( 0x3F00000000000000 ), + UINT64_C( 0x3F80000000000000 ), + UINT64_C( 0x3FC0000000000000 ), + UINT64_C( 0x3FE0000000000000 ), + UINT64_C( 0x3FF0000000000000 ), + UINT64_C( 0x3FF8000000000000 ), + UINT64_C( 0x3FFC000000000000 ) +}; + +static void f128RandomQInfP3( float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + int sigNum1, sigNum2; + uint_fast64_t sig1_0; + int weightMaskNum; + + uiZPtr = (struct uint128 *) zPtr; + sigNum1 = randomN_ui16( f128NumP2 ); + sigNum2 = randomN_ui16( f128NumP2 ); + sig1_0 = f128P2[sigNum1].v0; + uiZPtr->v0 = sig1_0 + f128P2[sigNum2].v0; + weightMaskNum = randomN_ui8( f128NumQInfWeightMasks ); + uiZPtr->v64 = + (((uint_fast64_t) random_ui16()<<48 + & f128QInfWeightMasks[weightMaskNum]) + + f128QInfWeightOffsets[weightMaskNum]) + | ((f128P2[sigNum1].v64 + f128P2[sigNum2].v64 + (uiZPtr->v0 < sig1_0)) + & UINT64_C( 0x0000FFFFFFFFFFFF )); + +} + +static void f128RandomQInfPInf( float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + int weightMaskNum; + + uiZPtr = (struct uint128 *) zPtr; + weightMaskNum = randomN_ui8( f128NumQInfWeightMasks ); + uiZPtr->v64 = + (random_ui64() + & (f128QInfWeightMasks[weightMaskNum] + | UINT64_C( 0x0000FFFFFFFFFFFF ))) + + f128QInfWeightOffsets[weightMaskNum]; + uiZPtr->v0 = random_ui64(); + +} + +static void f128Random( float128_t *zPtr ) +{ + + switch ( random_ui8() & 7 ) { + case 0: + case 1: + case 2: + f128RandomQOutP3( zPtr ); + break; + case 3: + f128RandomQOutPInf( zPtr ); + break; + case 4: + case 5: + case 6: + f128RandomQInfP3( zPtr ); + break; + case 7: + f128RandomQInfPInf( zPtr ); + break; + } + +} + +static struct sequence sequenceA, sequenceB, sequenceC; +static float128_t currentA, currentB, currentC; +static int subcase; + +float128_t genCases_f128_a, genCases_f128_b, genCases_f128_c; + +void genCases_f128_a_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = + (genCases_level == 1) ? 3 * f128NumQOutP1 : 2 * f128NumQOutP2; + genCases_done = false; + +} + +void genCases_f128_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + case 1: + f128Random( &genCases_f128_a ); + break; + case 2: + f128NextQOutP1( &sequenceA, &genCases_f128_a ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + f128Random( &genCases_f128_a ); + break; + case 1: + f128NextQOutP2( &sequenceA, &genCases_f128_a ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f128_ab_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 6 * f128NumQInP1 * f128NumQInP1; + f128NextQInP1( &sequenceA, ¤tA ); + } else { + genCases_total = 2 * f128NumQInP2 * f128NumQInP2; + f128NextQInP2( &sequenceA, ¤tA ); + } + genCases_done = false; + +} + +void genCases_f128_ab_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceB.done ) { + sequenceB.done = false; + f128NextQInP1( &sequenceA, ¤tA ); + } + f128NextQInP1( &sequenceB, ¤tB ); + case 2: + case 4: + f128Random( &genCases_f128_a ); + f128Random( &genCases_f128_b ); + break; + case 1: + genCases_f128_a = currentA; + f128Random( &genCases_f128_b ); + break; + case 3: + f128Random( &genCases_f128_a ); + genCases_f128_b = currentB; + break; + case 5: + genCases_f128_a = currentA; + genCases_f128_b = currentB; + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + f128Random( &genCases_f128_a ); + f128Random( &genCases_f128_b ); + break; + case 1: + if ( sequenceB.done ) { + sequenceB.done = false; + f128NextQInP2( &sequenceA, ¤tA ); + } + genCases_f128_a = currentA; + f128NextQInP2( &sequenceB, &genCases_f128_b ); + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f128_abc_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + sequenceC.expNum = 0; + sequenceC.term1Num = 0; + sequenceC.term2Num = 0; + sequenceC.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 9 * f128NumQInP1 * f128NumQInP1 * f128NumQInP1; + f128NextQInP1( &sequenceA, ¤tA ); + f128NextQInP1( &sequenceB, ¤tB ); + } else { + genCases_total = 2 * f128NumQInP2 * f128NumQInP2 * f128NumQInP2; + f128NextQInP2( &sequenceA, ¤tA ); + f128NextQInP2( &sequenceB, ¤tB ); + } + genCases_done = false; + +} + +void genCases_f128_abc_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + f128NextQInP1( &sequenceA, ¤tA ); + } + f128NextQInP1( &sequenceB, ¤tB ); + } + f128NextQInP1( &sequenceC, ¤tC ); + f128Random( &genCases_f128_a ); + f128Random( &genCases_f128_b ); + genCases_f128_c = currentC; + break; + case 1: + genCases_f128_a = currentA; + genCases_f128_b = currentB; + f128Random( &genCases_f128_c ); + break; + case 2: + f128Random( &genCases_f128_a ); + f128Random( &genCases_f128_b ); + f128Random( &genCases_f128_c ); + break; + case 3: + f128Random( &genCases_f128_a ); + genCases_f128_b = currentB; + genCases_f128_c = currentC; + break; + case 4: + genCases_f128_a = currentA; + f128Random( &genCases_f128_b ); + f128Random( &genCases_f128_c ); + break; + case 5: + f128Random( &genCases_f128_a ); + genCases_f128_b = currentB; + f128Random( &genCases_f128_c ); + break; + case 6: + genCases_f128_a = currentA; + f128Random( &genCases_f128_b ); + genCases_f128_c = currentC; + break; + case 7: + f128Random( &genCases_f128_a ); + f128Random( &genCases_f128_b ); + f128Random( &genCases_f128_c ); + break; + case 8: + genCases_f128_a = currentA; + genCases_f128_b = currentB; + genCases_f128_c = currentC; + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + f128Random( &genCases_f128_a ); + f128Random( &genCases_f128_b ); + f128Random( &genCases_f128_c ); + break; + case 1: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + f128NextQInP2( &sequenceA, ¤tA ); + } + f128NextQInP2( &sequenceB, ¤tB ); + } + genCases_f128_a = currentA; + genCases_f128_b = currentB; + f128NextQInP2( &sequenceC, &genCases_f128_c ); + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f16.c new file mode 100644 index 000000000..dd2ebbce4 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f16.c @@ -0,0 +1,585 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "softfloat.h" +#include "genCases.h" + +#ifdef FLOAT16 + +struct sequence { + int expNum, term1Num, term2Num; + bool done; +}; + +union ui16_f16 { uint16_t ui; float16_t f; }; + +enum { + f16NumQIn = 22, + f16NumQOut = 34, + f16NumP1 = 4, + f16NumP2 = 36 +}; +static const uint16_t f16QIn[f16NumQIn] = { + 0x0000, /* positive, subnormal */ + 0x0400, /* positive, -14 */ + 0x1000, /* positive, -11 */ + 0x3400, /* positive, -2 */ + 0x3800, /* positive, -1 */ + 0x3C00, /* positive, 0 */ + 0x4000, /* positive, 1 */ + 0x4400, /* positive, 2 */ + 0x6800, /* positive, 11 */ + 0x7800, /* positive, 15 */ + 0x7C00, /* positive, infinity or NaN */ + 0x8000, /* negative, subnormal */ + 0x8400, /* negative, -14 */ + 0x9000, /* negative, -11 */ + 0xB400, /* negative, -2 */ + 0xB800, /* negative, -1 */ + 0xBC00, /* negative, 0 */ + 0xC000, /* negative, 1 */ + 0xC400, /* negative, 2 */ + 0xE800, /* negative, 11 */ + 0xF800, /* negative, 15 */ + 0xFC00 /* negative, infinity or NaN */ +}; +static const uint16_t f16QOut[f16NumQOut] = { + 0x0000, /* positive, subnormal */ + 0x0400, /* positive, -14 */ + 0x0800, /* positive, -13 */ + 0x1000, /* positive, -11 */ + 0x2C00, /* positive, -4 */ + 0x3000, /* positive, -3 */ + 0x3400, /* positive, -2 */ + 0x3800, /* positive, -1 */ + 0x3C00, /* positive, 0 */ + 0x4000, /* positive, 1 */ + 0x4400, /* positive, 2 */ + 0x4800, /* positive, 3 */ + 0x4C00, /* positive, 4 */ + 0x6800, /* positive, 11 */ + 0x7400, /* positive, 14 */ + 0x7800, /* positive, 15 */ + 0x7C00, /* positive, infinity or NaN */ + 0x8000, /* negative, subnormal */ + 0x8400, /* negative, -14 */ + 0x8800, /* negative, -13 */ + 0x9000, /* negative, -11 */ + 0xAC00, /* negative, -4 */ + 0xB000, /* negative, -3 */ + 0xB400, /* negative, -2 */ + 0xB800, /* negative, -1 */ + 0xBC00, /* negative, 0 */ + 0xC000, /* negative, 1 */ + 0xC400, /* negative, 2 */ + 0xC800, /* negative, 3 */ + 0xCC00, /* negative, 4 */ + 0xE800, /* negative, 11 */ + 0xF400, /* negative, 14 */ + 0xF800, /* negative, 15 */ + 0xFC00 /* negative, infinity or NaN */ +}; +static const uint16_t f16P1[f16NumP1] = { + 0x0000, + 0x0001, + 0x03FF, + 0x03FE +}; +static const uint16_t f16P2[f16NumP2] = { + 0x0000, + 0x0001, + 0x0002, + 0x0004, + 0x0008, + 0x0010, + 0x0020, + 0x0040, + 0x0080, + 0x0100, + 0x0200, + 0x0300, + 0x0380, + 0x03C0, + 0x03E0, + 0x03F0, + 0x03F8, + 0x03FC, + 0x03FE, + 0x03FF, + 0x03FD, + 0x03FB, + 0x03F7, + 0x03EF, + 0x03DF, + 0x03BF, + 0x037F, + 0x02FF, + 0x01FF, + 0x00FF, + 0x007F, + 0x003F, + 0x001F, + 0x000F, + 0x0007, + 0x0003 +}; + +static const uint_fast64_t f16NumQInP1 = f16NumQIn * f16NumP1; +static const uint_fast64_t f16NumQOutP1 = f16NumQOut * f16NumP1; + +static float16_t f16NextQInP1( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui16_f16 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f16QIn[expNum] | f16P1[sigNum]; + ++sigNum; + if ( f16NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f16NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float16_t f16NextQOutP1( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui16_f16 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f16QOut[expNum] | f16P1[sigNum]; + ++sigNum; + if ( f16NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f16NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static const uint_fast64_t f16NumQInP2 = f16NumQIn * f16NumP2; +static const uint_fast64_t f16NumQOutP2 = f16NumQOut * f16NumP2; + +static float16_t f16NextQInP2( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui16_f16 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f16QIn[expNum] | f16P2[sigNum]; + ++sigNum; + if ( f16NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f16NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float16_t f16NextQOutP2( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui16_f16 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f16QOut[expNum] | f16P2[sigNum]; + ++sigNum; + if ( f16NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f16NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float16_t f16RandomQOutP3( void ) +{ + union ui16_f16 uZ; + + uZ.ui = + f16QOut[randomN_ui8( f16NumQOut )] + | ((f16P2[randomN_ui8( f16NumP2 )] + f16P2[randomN_ui8( f16NumP2 )]) + & 0x03FF); + return uZ.f; + +} + +static float16_t f16RandomQOutPInf( void ) +{ + union ui16_f16 uZ; + + uZ.ui = f16QOut[randomN_ui8( f16NumQOut )] | (random_ui16() & 0x03FF); + return uZ.f; + +} + +enum { f16NumQInfWeightMasks = 4 }; +static const uint16_t f16QInfWeightMasks[f16NumQInfWeightMasks] = + { 0xFC00, 0xFC00, 0xBC00, 0x9C00 }; +static const uint16_t f16QInfWeightOffsets[f16NumQInfWeightMasks] = + { 0x0000, 0x0000, 0x2000, 0x3000 }; + +static float16_t f16RandomQInfP3( void ) +{ + int weightMaskNum; + union ui16_f16 uZ; + + weightMaskNum = randomN_ui8( f16NumQInfWeightMasks ); + uZ.ui = + ((random_ui16() & f16QInfWeightMasks[weightMaskNum]) + + f16QInfWeightOffsets[weightMaskNum]) + | ((f16P2[randomN_ui8( f16NumP2 )] + f16P2[randomN_ui8( f16NumP2 )]) + & 0x03FF); + return uZ.f; + +} + +static float16_t f16RandomQInfPInf( void ) +{ + int weightMaskNum; + union ui16_f16 uZ; + + weightMaskNum = randomN_ui8( f16NumQInfWeightMasks ); + uZ.ui = + (random_ui16() & (f16QInfWeightMasks[weightMaskNum] | 0x03FF)) + + f16QInfWeightOffsets[weightMaskNum]; + return uZ.f; + +} + +static float16_t f16Random( void ) +{ + + switch ( random_ui8() & 7 ) { + case 0: + case 1: + case 2: + return f16RandomQOutP3(); + case 3: + return f16RandomQOutPInf(); + case 4: + case 5: + case 6: + return f16RandomQInfP3(); + case 7: + return f16RandomQInfPInf(); + } + +} + +static struct sequence sequenceA, sequenceB, sequenceC; +static float16_t currentA, currentB, currentC; +static int subcase; + +float16_t genCases_f16_a, genCases_f16_b, genCases_f16_c; + +void genCases_f16_a_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = + (genCases_level == 1) ? 3 * f16NumQOutP1 : 2 * f16NumQOutP2; + genCases_done = false; + +} + +void genCases_f16_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + case 1: + genCases_f16_a = f16Random(); + break; + case 2: + genCases_f16_a = f16NextQOutP1( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f16_a = f16Random(); + break; + case 1: + genCases_f16_a = f16NextQOutP2( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f16_ab_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 6 * f16NumQInP1 * f16NumQInP1; + currentA = f16NextQInP1( &sequenceA ); + } else { + genCases_total = 2 * f16NumQInP2 * f16NumQInP2; + currentA = f16NextQInP2( &sequenceA ); + } + genCases_done = false; + +} + +void genCases_f16_ab_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f16NextQInP1( &sequenceA ); + } + currentB = f16NextQInP1( &sequenceB ); + case 2: + case 4: + genCases_f16_a = f16Random(); + genCases_f16_b = f16Random(); + break; + case 1: + genCases_f16_a = currentA; + genCases_f16_b = f16Random(); + break; + case 3: + genCases_f16_a = f16Random(); + genCases_f16_b = currentB; + break; + case 5: + genCases_f16_a = currentA; + genCases_f16_b = currentB; + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f16_a = f16Random(); + genCases_f16_b = f16Random(); + break; + case 1: + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f16NextQInP2( &sequenceA ); + } + genCases_f16_a = currentA; + genCases_f16_b = f16NextQInP2( &sequenceB ); + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f16_abc_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + sequenceC.expNum = 0; + sequenceC.term1Num = 0; + sequenceC.term2Num = 0; + sequenceC.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 9 * f16NumQInP1 * f16NumQInP1 * f16NumQInP1; + currentA = f16NextQInP1( &sequenceA ); + currentB = f16NextQInP1( &sequenceB ); + } else { + genCases_total = 2 * f16NumQInP2 * f16NumQInP2 * f16NumQInP2; + currentA = f16NextQInP2( &sequenceA ); + currentB = f16NextQInP2( &sequenceB ); + } + genCases_done = false; + +} + +void genCases_f16_abc_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f16NextQInP1( &sequenceA ); + } + currentB = f16NextQInP1( &sequenceB ); + } + currentC = f16NextQInP1( &sequenceC ); + genCases_f16_a = f16Random(); + genCases_f16_b = f16Random(); + genCases_f16_c = currentC; + break; + case 1: + genCases_f16_a = currentA; + genCases_f16_b = currentB; + genCases_f16_c = f16Random(); + break; + case 2: + genCases_f16_a = f16Random(); + genCases_f16_b = f16Random(); + genCases_f16_c = f16Random(); + break; + case 3: + genCases_f16_a = f16Random(); + genCases_f16_b = currentB; + genCases_f16_c = currentC; + break; + case 4: + genCases_f16_a = currentA; + genCases_f16_b = f16Random(); + genCases_f16_c = f16Random(); + break; + case 5: + genCases_f16_a = f16Random(); + genCases_f16_b = currentB; + genCases_f16_c = f16Random(); + break; + case 6: + genCases_f16_a = currentA; + genCases_f16_b = f16Random(); + genCases_f16_c = currentC; + break; + case 7: + genCases_f16_a = f16Random(); + genCases_f16_b = f16Random(); + genCases_f16_c = f16Random(); + break; + case 8: + genCases_f16_a = currentA; + genCases_f16_b = currentB; + genCases_f16_c = currentC; + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f16_a = f16Random(); + genCases_f16_b = f16Random(); + genCases_f16_c = f16Random(); + break; + case 1: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f16NextQInP2( &sequenceA ); + } + currentB = f16NextQInP2( &sequenceB ); + } + genCases_f16_a = currentA; + genCases_f16_b = currentB; + genCases_f16_c = f16NextQInP2( &sequenceC ); + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f32.c new file mode 100644 index 000000000..bb08ae902 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f32.c @@ -0,0 +1,664 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "softfloat.h" +#include "genCases.h" + +struct sequence { + int expNum, term1Num, term2Num; + bool done; +}; + +union ui32_f32 { uint32_t ui; float32_t f; }; + +enum { + f32NumQIn = 22, + f32NumQOut = 50, + f32NumP1 = 4, + f32NumP2 = 88 +}; +static const uint32_t f32QIn[f32NumQIn] = { + 0x00000000, /* positive, subnormal */ + 0x00800000, /* positive, -126 */ + 0x33800000, /* positive, -24 */ + 0x3E800000, /* positive, -2 */ + 0x3F000000, /* positive, -1 */ + 0x3F800000, /* positive, 0 */ + 0x40000000, /* positive, 1 */ + 0x40800000, /* positive, 2 */ + 0x4B800000, /* positive, 24 */ + 0x7F000000, /* positive, 127 */ + 0x7F800000, /* positive, infinity or NaN */ + 0x80000000, /* negative, subnormal */ + 0x80800000, /* negative, -126 */ + 0xB3800000, /* negative, -24 */ + 0xBE800000, /* negative, -2 */ + 0xBF000000, /* negative, -1 */ + 0xBF800000, /* negative, 0 */ + 0xC0000000, /* negative, 1 */ + 0xC0800000, /* negative, 2 */ + 0xCB800000, /* negative, 24 */ + 0xFE800000, /* negative, 126 */ + 0xFF800000 /* negative, infinity or NaN */ +}; +static const uint32_t f32QOut[f32NumQOut] = { + 0x00000000, /* positive, subnormal */ + 0x00800000, /* positive, -126 */ + 0x01000000, /* positive, -125 */ + 0x33800000, /* positive, -24 */ + 0x3D800000, /* positive, -4 */ + 0x3E000000, /* positive, -3 */ + 0x3E800000, /* positive, -2 */ + 0x3F000000, /* positive, -1 */ + 0x3F800000, /* positive, 0 */ + 0x40000000, /* positive, 1 */ + 0x40800000, /* positive, 2 */ + 0x41000000, /* positive, 3 */ + 0x41800000, /* positive, 4 */ + 0x4B800000, /* positive, 24 */ + 0x4E000000, /* positive, 29 */ + 0x4E800000, /* positive, 30 */ + 0x4F000000, /* positive, 31 */ + 0x4F800000, /* positive, 32 */ + 0x5E000000, /* positive, 61 */ + 0x5E800000, /* positive, 62 */ + 0x5F000000, /* positive, 63 */ + 0x5F800000, /* positive, 64 */ + 0x7E800000, /* positive, 126 */ + 0x7F000000, /* positive, 127 */ + 0x7F800000, /* positive, infinity or NaN */ + 0x80000000, /* negative, subnormal */ + 0x80800000, /* negative, -126 */ + 0x81000000, /* negative, -125 */ + 0xB3800000, /* negative, -24 */ + 0xBD800000, /* negative, -4 */ + 0xBE000000, /* negative, -3 */ + 0xBE800000, /* negative, -2 */ + 0xBF000000, /* negative, -1 */ + 0xBF800000, /* negative, 0 */ + 0xC0000000, /* negative, 1 */ + 0xC0800000, /* negative, 2 */ + 0xC1000000, /* negative, 3 */ + 0xC1800000, /* negative, 4 */ + 0xCB800000, /* negative, 24 */ + 0xCE000000, /* negative, 29 */ + 0xCE800000, /* negative, 30 */ + 0xCF000000, /* negative, 31 */ + 0xCF800000, /* negative, 32 */ + 0xDE000000, /* negative, 61 */ + 0xDE800000, /* negative, 62 */ + 0xDF000000, /* negative, 63 */ + 0xDF800000, /* negative, 64 */ + 0xFE800000, /* negative, 126 */ + 0xFF000000, /* negative, 127 */ + 0xFF800000 /* negative, infinity or NaN */ +}; +static const uint32_t f32P1[f32NumP1] = { + 0x00000000, + 0x00000001, + 0x007FFFFF, + 0x007FFFFE +}; +static const uint32_t f32P2[f32NumP2] = { + 0x00000000, + 0x00000001, + 0x00000002, + 0x00000004, + 0x00000008, + 0x00000010, + 0x00000020, + 0x00000040, + 0x00000080, + 0x00000100, + 0x00000200, + 0x00000400, + 0x00000800, + 0x00001000, + 0x00002000, + 0x00004000, + 0x00008000, + 0x00010000, + 0x00020000, + 0x00040000, + 0x00080000, + 0x00100000, + 0x00200000, + 0x00400000, + 0x00600000, + 0x00700000, + 0x00780000, + 0x007C0000, + 0x007E0000, + 0x007F0000, + 0x007F8000, + 0x007FC000, + 0x007FE000, + 0x007FF000, + 0x007FF800, + 0x007FFC00, + 0x007FFE00, + 0x007FFF00, + 0x007FFF80, + 0x007FFFC0, + 0x007FFFE0, + 0x007FFFF0, + 0x007FFFF8, + 0x007FFFFC, + 0x007FFFFE, + 0x007FFFFF, + 0x007FFFFD, + 0x007FFFFB, + 0x007FFFF7, + 0x007FFFEF, + 0x007FFFDF, + 0x007FFFBF, + 0x007FFF7F, + 0x007FFEFF, + 0x007FFDFF, + 0x007FFBFF, + 0x007FF7FF, + 0x007FEFFF, + 0x007FDFFF, + 0x007FBFFF, + 0x007F7FFF, + 0x007EFFFF, + 0x007DFFFF, + 0x007BFFFF, + 0x0077FFFF, + 0x006FFFFF, + 0x005FFFFF, + 0x003FFFFF, + 0x001FFFFF, + 0x000FFFFF, + 0x0007FFFF, + 0x0003FFFF, + 0x0001FFFF, + 0x0000FFFF, + 0x00007FFF, + 0x00003FFF, + 0x00001FFF, + 0x00000FFF, + 0x000007FF, + 0x000003FF, + 0x000001FF, + 0x000000FF, + 0x0000007F, + 0x0000003F, + 0x0000001F, + 0x0000000F, + 0x00000007, + 0x00000003 +}; + +static const uint_fast64_t f32NumQInP1 = f32NumQIn * f32NumP1; +static const uint_fast64_t f32NumQOutP1 = f32NumQOut * f32NumP1; + +static float32_t f32NextQInP1( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui32_f32 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f32QIn[expNum] | f32P1[sigNum]; + ++sigNum; + if ( f32NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f32NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float32_t f32NextQOutP1( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui32_f32 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f32QOut[expNum] | f32P1[sigNum]; + ++sigNum; + if ( f32NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f32NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static const uint_fast64_t f32NumQInP2 = f32NumQIn * f32NumP2; +static const uint_fast64_t f32NumQOutP2 = f32NumQOut * f32NumP2; + +static float32_t f32NextQInP2( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui32_f32 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f32QIn[expNum] | f32P2[sigNum]; + ++sigNum; + if ( f32NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f32NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float32_t f32NextQOutP2( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui32_f32 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f32QOut[expNum] | f32P2[sigNum]; + ++sigNum; + if ( f32NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f32NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float32_t f32RandomQOutP3( void ) +{ + union ui32_f32 uZ; + + uZ.ui = + f32QOut[randomN_ui8( f32NumQOut )] + | ((f32P2[randomN_ui8( f32NumP2 )] + f32P2[randomN_ui8( f32NumP2 )]) + & 0x007FFFFF); + return uZ.f; + +} + +static float32_t f32RandomQOutPInf( void ) +{ + union ui32_f32 uZ; + + uZ.ui = f32QOut[randomN_ui8( f32NumQOut )] | (random_ui32() & 0x007FFFFF); + return uZ.f; + +} + +enum { f32NumQInfWeightMasks = 7 }; +static const uint32_t f32QInfWeightMasks[f32NumQInfWeightMasks] = { + 0xFF800000, + 0xFF800000, + 0xBF800000, + 0x9F800000, + 0x8F800000, + 0x87800000, + 0x83800000 +}; +static const uint32_t f32QInfWeightOffsets[f32NumQInfWeightMasks] = { + 0x00000000, + 0x00000000, + 0x20000000, + 0x30000000, + 0x38000000, + 0x3C000000, + 0x3E000000 +}; + +static float32_t f32RandomQInfP3( void ) +{ + int weightMaskNum; + union ui32_f32 uZ; + + weightMaskNum = randomN_ui8( f32NumQInfWeightMasks ); + uZ.ui = + (((uint_fast32_t) random_ui16()<<16 + & f32QInfWeightMasks[weightMaskNum]) + + f32QInfWeightOffsets[weightMaskNum]) + | ((f32P2[randomN_ui8( f32NumP2 )] + f32P2[randomN_ui8( f32NumP2 )]) + & 0x007FFFFF); + return uZ.f; + +} + +static float32_t f32RandomQInfPInf( void ) +{ + int weightMaskNum; + union ui32_f32 uZ; + + weightMaskNum = randomN_ui8( f32NumQInfWeightMasks ); + uZ.ui = + (random_ui32() & (f32QInfWeightMasks[weightMaskNum] | 0x007FFFFF)) + + f32QInfWeightOffsets[weightMaskNum]; + return uZ.f; + +} + +static float32_t f32Random( void ) +{ + + switch ( random_ui8() & 7 ) { + case 0: + case 1: + case 2: + return f32RandomQOutP3(); + case 3: + return f32RandomQOutPInf(); + case 4: + case 5: + case 6: + return f32RandomQInfP3(); + case 7: + return f32RandomQInfPInf(); + } + +} + +static struct sequence sequenceA, sequenceB, sequenceC; +static float32_t currentA, currentB, currentC; +static int subcase; + +float32_t genCases_f32_a, genCases_f32_b, genCases_f32_c; + +void genCases_f32_a_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = + (genCases_level == 1) ? 3 * f32NumQOutP1 : 2 * f32NumQOutP2; + genCases_done = false; + +} + +void genCases_f32_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + case 1: + genCases_f32_a = f32Random(); + break; + case 2: + genCases_f32_a = f32NextQOutP1( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f32_a = f32Random(); + break; + case 1: + genCases_f32_a = f32NextQOutP2( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f32_ab_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 6 * f32NumQInP1 * f32NumQInP1; + currentA = f32NextQInP1( &sequenceA ); + } else { + genCases_total = 2 * f32NumQInP2 * f32NumQInP2; + currentA = f32NextQInP2( &sequenceA ); + } + genCases_done = false; + +} + +void genCases_f32_ab_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f32NextQInP1( &sequenceA ); + } + currentB = f32NextQInP1( &sequenceB ); + case 2: + case 4: + genCases_f32_a = f32Random(); + genCases_f32_b = f32Random(); + break; + case 1: + genCases_f32_a = currentA; + genCases_f32_b = f32Random(); + break; + case 3: + genCases_f32_a = f32Random(); + genCases_f32_b = currentB; + break; + case 5: + genCases_f32_a = currentA; + genCases_f32_b = currentB; + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f32_a = f32Random(); + genCases_f32_b = f32Random(); + break; + case 1: + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f32NextQInP2( &sequenceA ); + } + genCases_f32_a = currentA; + genCases_f32_b = f32NextQInP2( &sequenceB ); + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f32_abc_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + sequenceC.expNum = 0; + sequenceC.term1Num = 0; + sequenceC.term2Num = 0; + sequenceC.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 9 * f32NumQInP1 * f32NumQInP1 * f32NumQInP1; + currentA = f32NextQInP1( &sequenceA ); + currentB = f32NextQInP1( &sequenceB ); + } else { + genCases_total = 2 * f32NumQInP2 * f32NumQInP2 * f32NumQInP2; + currentA = f32NextQInP2( &sequenceA ); + currentB = f32NextQInP2( &sequenceB ); + } + genCases_done = false; + +} + +void genCases_f32_abc_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f32NextQInP1( &sequenceA ); + } + currentB = f32NextQInP1( &sequenceB ); + } + currentC = f32NextQInP1( &sequenceC ); + genCases_f32_a = f32Random(); + genCases_f32_b = f32Random(); + genCases_f32_c = currentC; + break; + case 1: + genCases_f32_a = currentA; + genCases_f32_b = currentB; + genCases_f32_c = f32Random(); + break; + case 2: + genCases_f32_a = f32Random(); + genCases_f32_b = f32Random(); + genCases_f32_c = f32Random(); + break; + case 3: + genCases_f32_a = f32Random(); + genCases_f32_b = currentB; + genCases_f32_c = currentC; + break; + case 4: + genCases_f32_a = currentA; + genCases_f32_b = f32Random(); + genCases_f32_c = f32Random(); + break; + case 5: + genCases_f32_a = f32Random(); + genCases_f32_b = currentB; + genCases_f32_c = f32Random(); + break; + case 6: + genCases_f32_a = currentA; + genCases_f32_b = f32Random(); + genCases_f32_c = currentC; + break; + case 7: + genCases_f32_a = f32Random(); + genCases_f32_b = f32Random(); + genCases_f32_c = f32Random(); + break; + case 8: + genCases_f32_a = currentA; + genCases_f32_b = currentB; + genCases_f32_c = currentC; + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f32_a = f32Random(); + genCases_f32_b = f32Random(); + genCases_f32_c = f32Random(); + break; + case 1: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f32NextQInP2( &sequenceA ); + } + currentB = f32NextQInP2( &sequenceB ); + } + genCases_f32_a = currentA; + genCases_f32_b = currentB; + genCases_f32_c = f32NextQInP2( &sequenceC ); + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } + ++subcase; + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f64.c new file mode 100644 index 000000000..61b34dc2e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_f64.c @@ -0,0 +1,808 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "softfloat.h" +#include "genCases.h" + +#ifdef FLOAT64 + +struct sequence { + int expNum, term1Num, term2Num; + bool done; +}; + +union ui64_f64 { uint64_t ui; float64_t f; }; + +enum { + f64NumQIn = 22, + f64NumQOut = 64, + f64NumP1 = 4, + f64NumP2 = 204 +}; +static const uint64_t f64QIn[f64NumQIn] = { + UINT64_C( 0x0000000000000000 ), /* positive, subnormal */ + UINT64_C( 0x0010000000000000 ), /* positive, -1022 */ + UINT64_C( 0x3CA0000000000000 ), /* positive, -53 */ + UINT64_C( 0x3FD0000000000000 ), /* positive, -2 */ + UINT64_C( 0x3FE0000000000000 ), /* positive, -1 */ + UINT64_C( 0x3FF0000000000000 ), /* positive, 0 */ + UINT64_C( 0x4000000000000000 ), /* positive, 1 */ + UINT64_C( 0x4010000000000000 ), /* positive, 2 */ + UINT64_C( 0x4340000000000000 ), /* positive, 53 */ + UINT64_C( 0x7FE0000000000000 ), /* positive, 1023 */ + UINT64_C( 0x7FF0000000000000 ), /* positive, infinity or NaN */ + UINT64_C( 0x8000000000000000 ), /* negative, subnormal */ + UINT64_C( 0x8010000000000000 ), /* negative, -1022 */ + UINT64_C( 0xBCA0000000000000 ), /* negative, -53 */ + UINT64_C( 0xBFD0000000000000 ), /* negative, -2 */ + UINT64_C( 0xBFE0000000000000 ), /* negative, -1 */ + UINT64_C( 0xBFF0000000000000 ), /* negative, 0 */ + UINT64_C( 0xC000000000000000 ), /* negative, 1 */ + UINT64_C( 0xC010000000000000 ), /* negative, 2 */ + UINT64_C( 0xC340000000000000 ), /* negative, 53 */ + UINT64_C( 0xFFE0000000000000 ), /* negative, 1023 */ + UINT64_C( 0xFFF0000000000000 ) /* negative, infinity or NaN */ +}; +static const uint64_t f64QOut[f64NumQOut] = { + UINT64_C( 0x0000000000000000 ), /* positive, subnormal */ + UINT64_C( 0x0010000000000000 ), /* positive, -1022 */ + UINT64_C( 0x0020000000000000 ), /* positive, -1021 */ + UINT64_C( 0x37E0000000000000 ), /* positive, -129 */ + UINT64_C( 0x37F0000000000000 ), /* positive, -128 */ + UINT64_C( 0x3800000000000000 ), /* positive, -127 */ + UINT64_C( 0x3810000000000000 ), /* positive, -126 */ + UINT64_C( 0x3CA0000000000000 ), /* positive, -53 */ + UINT64_C( 0x3FB0000000000000 ), /* positive, -4 */ + UINT64_C( 0x3FC0000000000000 ), /* positive, -3 */ + UINT64_C( 0x3FD0000000000000 ), /* positive, -2 */ + UINT64_C( 0x3FE0000000000000 ), /* positive, -1 */ + UINT64_C( 0x3FF0000000000000 ), /* positive, 0 */ + UINT64_C( 0x4000000000000000 ), /* positive, 1 */ + UINT64_C( 0x4010000000000000 ), /* positive, 2 */ + UINT64_C( 0x4020000000000000 ), /* positive, 3 */ + UINT64_C( 0x4030000000000000 ), /* positive, 4 */ + UINT64_C( 0x41C0000000000000 ), /* positive, 29 */ + UINT64_C( 0x41D0000000000000 ), /* positive, 30 */ + UINT64_C( 0x41E0000000000000 ), /* positive, 31 */ + UINT64_C( 0x41F0000000000000 ), /* positive, 32 */ + UINT64_C( 0x4340000000000000 ), /* positive, 53 */ + UINT64_C( 0x43C0000000000000 ), /* positive, 61 */ + UINT64_C( 0x43D0000000000000 ), /* positive, 62 */ + UINT64_C( 0x43E0000000000000 ), /* positive, 63 */ + UINT64_C( 0x43F0000000000000 ), /* positive, 64 */ + UINT64_C( 0x47E0000000000000 ), /* positive, 127 */ + UINT64_C( 0x47F0000000000000 ), /* positive, 128 */ + UINT64_C( 0x4800000000000000 ), /* positive, 129 */ + UINT64_C( 0x7FD0000000000000 ), /* positive, 1022 */ + UINT64_C( 0x7FE0000000000000 ), /* positive, 1023 */ + UINT64_C( 0x7FF0000000000000 ), /* positive, infinity or NaN */ + UINT64_C( 0x8000000000000000 ), /* negative, subnormal */ + UINT64_C( 0x8010000000000000 ), /* negative, -1022 */ + UINT64_C( 0x8020000000000000 ), /* negative, -1021 */ + UINT64_C( 0xB7E0000000000000 ), /* negative, -129 */ + UINT64_C( 0xB7F0000000000000 ), /* negative, -128 */ + UINT64_C( 0xB800000000000000 ), /* negative, -127 */ + UINT64_C( 0xB810000000000000 ), /* negative, -126 */ + UINT64_C( 0xBCA0000000000000 ), /* negative, -53 */ + UINT64_C( 0xBFB0000000000000 ), /* negative, -4 */ + UINT64_C( 0xBFC0000000000000 ), /* negative, -3 */ + UINT64_C( 0xBFD0000000000000 ), /* negative, -2 */ + UINT64_C( 0xBFE0000000000000 ), /* negative, -1 */ + UINT64_C( 0xBFF0000000000000 ), /* negative, 0 */ + UINT64_C( 0xC000000000000000 ), /* negative, 1 */ + UINT64_C( 0xC010000000000000 ), /* negative, 2 */ + UINT64_C( 0xC020000000000000 ), /* negative, 3 */ + UINT64_C( 0xC030000000000000 ), /* negative, 4 */ + UINT64_C( 0xC1C0000000000000 ), /* negative, 29 */ + UINT64_C( 0xC1D0000000000000 ), /* negative, 30 */ + UINT64_C( 0xC1E0000000000000 ), /* negative, 31 */ + UINT64_C( 0xC1F0000000000000 ), /* negative, 32 */ + UINT64_C( 0xC340000000000000 ), /* negative, 53 */ + UINT64_C( 0xC3C0000000000000 ), /* negative, 61 */ + UINT64_C( 0xC3D0000000000000 ), /* negative, 62 */ + UINT64_C( 0xC3E0000000000000 ), /* negative, 63 */ + UINT64_C( 0xC3F0000000000000 ), /* negative, 64 */ + UINT64_C( 0xC7E0000000000000 ), /* negative, 127 */ + UINT64_C( 0xC7F0000000000000 ), /* negative, 128 */ + UINT64_C( 0xC800000000000000 ), /* negative, 129 */ + UINT64_C( 0xFFD0000000000000 ), /* negative, 1022 */ + UINT64_C( 0xFFE0000000000000 ), /* negative, 1023 */ + UINT64_C( 0xFFF0000000000000 ) /* negative, infinity or NaN */ +}; +static const uint64_t f64P1[f64NumP1] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000001 ), + UINT64_C( 0x000FFFFFFFFFFFFF ), + UINT64_C( 0x000FFFFFFFFFFFFE ) +}; +static const uint64_t f64P2[f64NumP2] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000001 ), + UINT64_C( 0x0000000000000002 ), + UINT64_C( 0x0000000000000004 ), + UINT64_C( 0x0000000000000008 ), + UINT64_C( 0x0000000000000010 ), + UINT64_C( 0x0000000000000020 ), + UINT64_C( 0x0000000000000040 ), + UINT64_C( 0x0000000000000080 ), + UINT64_C( 0x0000000000000100 ), + UINT64_C( 0x0000000000000200 ), + UINT64_C( 0x0000000000000400 ), + UINT64_C( 0x0000000000000800 ), + UINT64_C( 0x0000000000001000 ), + UINT64_C( 0x0000000000002000 ), + UINT64_C( 0x0000000000004000 ), + UINT64_C( 0x0000000000008000 ), + UINT64_C( 0x0000000000010000 ), + UINT64_C( 0x0000000000020000 ), + UINT64_C( 0x0000000000040000 ), + UINT64_C( 0x0000000000080000 ), + UINT64_C( 0x0000000000100000 ), + UINT64_C( 0x0000000000200000 ), + UINT64_C( 0x0000000000400000 ), + UINT64_C( 0x0000000000800000 ), + UINT64_C( 0x0000000001000000 ), + UINT64_C( 0x0000000002000000 ), + UINT64_C( 0x0000000004000000 ), + UINT64_C( 0x0000000008000000 ), + UINT64_C( 0x0000000010000000 ), + UINT64_C( 0x0000000020000000 ), + UINT64_C( 0x0000000040000000 ), + UINT64_C( 0x0000000080000000 ), + UINT64_C( 0x0000000100000000 ), + UINT64_C( 0x0000000200000000 ), + UINT64_C( 0x0000000400000000 ), + UINT64_C( 0x0000000800000000 ), + UINT64_C( 0x0000001000000000 ), + UINT64_C( 0x0000002000000000 ), + UINT64_C( 0x0000004000000000 ), + UINT64_C( 0x0000008000000000 ), + UINT64_C( 0x0000010000000000 ), + UINT64_C( 0x0000020000000000 ), + UINT64_C( 0x0000040000000000 ), + UINT64_C( 0x0000080000000000 ), + UINT64_C( 0x0000100000000000 ), + UINT64_C( 0x0000200000000000 ), + UINT64_C( 0x0000400000000000 ), + UINT64_C( 0x0000800000000000 ), + UINT64_C( 0x0001000000000000 ), + UINT64_C( 0x0002000000000000 ), + UINT64_C( 0x0004000000000000 ), + UINT64_C( 0x0008000000000000 ), + UINT64_C( 0x000C000000000000 ), + UINT64_C( 0x000E000000000000 ), + UINT64_C( 0x000F000000000000 ), + UINT64_C( 0x000F800000000000 ), + UINT64_C( 0x000FC00000000000 ), + UINT64_C( 0x000FE00000000000 ), + UINT64_C( 0x000FF00000000000 ), + UINT64_C( 0x000FF80000000000 ), + UINT64_C( 0x000FFC0000000000 ), + UINT64_C( 0x000FFE0000000000 ), + UINT64_C( 0x000FFF0000000000 ), + UINT64_C( 0x000FFF8000000000 ), + UINT64_C( 0x000FFFC000000000 ), + UINT64_C( 0x000FFFE000000000 ), + UINT64_C( 0x000FFFF000000000 ), + UINT64_C( 0x000FFFF800000000 ), + UINT64_C( 0x000FFFFC00000000 ), + UINT64_C( 0x000FFFFE00000000 ), + UINT64_C( 0x000FFFFF00000000 ), + UINT64_C( 0x000FFFFF80000000 ), + UINT64_C( 0x000FFFFFC0000000 ), + UINT64_C( 0x000FFFFFE0000000 ), + UINT64_C( 0x000FFFFFF0000000 ), + UINT64_C( 0x000FFFFFF8000000 ), + UINT64_C( 0x000FFFFFFC000000 ), + UINT64_C( 0x000FFFFFFE000000 ), + UINT64_C( 0x000FFFFFFF000000 ), + UINT64_C( 0x000FFFFFFF800000 ), + UINT64_C( 0x000FFFFFFFC00000 ), + UINT64_C( 0x000FFFFFFFE00000 ), + UINT64_C( 0x000FFFFFFFF00000 ), + UINT64_C( 0x000FFFFFFFF80000 ), + UINT64_C( 0x000FFFFFFFFC0000 ), + UINT64_C( 0x000FFFFFFFFE0000 ), + UINT64_C( 0x000FFFFFFFFF0000 ), + UINT64_C( 0x000FFFFFFFFF8000 ), + UINT64_C( 0x000FFFFFFFFFC000 ), + UINT64_C( 0x000FFFFFFFFFE000 ), + UINT64_C( 0x000FFFFFFFFFF000 ), + UINT64_C( 0x000FFFFFFFFFF800 ), + UINT64_C( 0x000FFFFFFFFFFC00 ), + UINT64_C( 0x000FFFFFFFFFFE00 ), + UINT64_C( 0x000FFFFFFFFFFF00 ), + UINT64_C( 0x000FFFFFFFFFFF80 ), + UINT64_C( 0x000FFFFFFFFFFFC0 ), + UINT64_C( 0x000FFFFFFFFFFFE0 ), + UINT64_C( 0x000FFFFFFFFFFFF0 ), + UINT64_C( 0x000FFFFFFFFFFFF8 ), + UINT64_C( 0x000FFFFFFFFFFFFC ), + UINT64_C( 0x000FFFFFFFFFFFFE ), + UINT64_C( 0x000FFFFFFFFFFFFF ), + UINT64_C( 0x000FFFFFFFFFFFFD ), + UINT64_C( 0x000FFFFFFFFFFFFB ), + UINT64_C( 0x000FFFFFFFFFFFF7 ), + UINT64_C( 0x000FFFFFFFFFFFEF ), + UINT64_C( 0x000FFFFFFFFFFFDF ), + UINT64_C( 0x000FFFFFFFFFFFBF ), + UINT64_C( 0x000FFFFFFFFFFF7F ), + UINT64_C( 0x000FFFFFFFFFFEFF ), + UINT64_C( 0x000FFFFFFFFFFDFF ), + UINT64_C( 0x000FFFFFFFFFFBFF ), + UINT64_C( 0x000FFFFFFFFFF7FF ), + UINT64_C( 0x000FFFFFFFFFEFFF ), + UINT64_C( 0x000FFFFFFFFFDFFF ), + UINT64_C( 0x000FFFFFFFFFBFFF ), + UINT64_C( 0x000FFFFFFFFF7FFF ), + UINT64_C( 0x000FFFFFFFFEFFFF ), + UINT64_C( 0x000FFFFFFFFDFFFF ), + UINT64_C( 0x000FFFFFFFFBFFFF ), + UINT64_C( 0x000FFFFFFFF7FFFF ), + UINT64_C( 0x000FFFFFFFEFFFFF ), + UINT64_C( 0x000FFFFFFFDFFFFF ), + UINT64_C( 0x000FFFFFFFBFFFFF ), + UINT64_C( 0x000FFFFFFF7FFFFF ), + UINT64_C( 0x000FFFFFFEFFFFFF ), + UINT64_C( 0x000FFFFFFDFFFFFF ), + UINT64_C( 0x000FFFFFFBFFFFFF ), + UINT64_C( 0x000FFFFFF7FFFFFF ), + UINT64_C( 0x000FFFFFEFFFFFFF ), + UINT64_C( 0x000FFFFFDFFFFFFF ), + UINT64_C( 0x000FFFFFBFFFFFFF ), + UINT64_C( 0x000FFFFF7FFFFFFF ), + UINT64_C( 0x000FFFFEFFFFFFFF ), + UINT64_C( 0x000FFFFDFFFFFFFF ), + UINT64_C( 0x000FFFFBFFFFFFFF ), + UINT64_C( 0x000FFFF7FFFFFFFF ), + UINT64_C( 0x000FFFEFFFFFFFFF ), + UINT64_C( 0x000FFFDFFFFFFFFF ), + UINT64_C( 0x000FFFBFFFFFFFFF ), + UINT64_C( 0x000FFF7FFFFFFFFF ), + UINT64_C( 0x000FFEFFFFFFFFFF ), + UINT64_C( 0x000FFDFFFFFFFFFF ), + UINT64_C( 0x000FFBFFFFFFFFFF ), + UINT64_C( 0x000FF7FFFFFFFFFF ), + UINT64_C( 0x000FEFFFFFFFFFFF ), + UINT64_C( 0x000FDFFFFFFFFFFF ), + UINT64_C( 0x000FBFFFFFFFFFFF ), + UINT64_C( 0x000F7FFFFFFFFFFF ), + UINT64_C( 0x000EFFFFFFFFFFFF ), + UINT64_C( 0x000DFFFFFFFFFFFF ), + UINT64_C( 0x000BFFFFFFFFFFFF ), + UINT64_C( 0x0007FFFFFFFFFFFF ), + UINT64_C( 0x0003FFFFFFFFFFFF ), + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0x0000FFFFFFFFFFFF ), + UINT64_C( 0x00007FFFFFFFFFFF ), + UINT64_C( 0x00003FFFFFFFFFFF ), + UINT64_C( 0x00001FFFFFFFFFFF ), + UINT64_C( 0x00000FFFFFFFFFFF ), + UINT64_C( 0x000007FFFFFFFFFF ), + UINT64_C( 0x000003FFFFFFFFFF ), + UINT64_C( 0x000001FFFFFFFFFF ), + UINT64_C( 0x000000FFFFFFFFFF ), + UINT64_C( 0x0000007FFFFFFFFF ), + UINT64_C( 0x0000003FFFFFFFFF ), + UINT64_C( 0x0000001FFFFFFFFF ), + UINT64_C( 0x0000000FFFFFFFFF ), + UINT64_C( 0x00000007FFFFFFFF ), + UINT64_C( 0x00000003FFFFFFFF ), + UINT64_C( 0x00000001FFFFFFFF ), + UINT64_C( 0x00000000FFFFFFFF ), + UINT64_C( 0x000000007FFFFFFF ), + UINT64_C( 0x000000003FFFFFFF ), + UINT64_C( 0x000000001FFFFFFF ), + UINT64_C( 0x000000000FFFFFFF ), + UINT64_C( 0x0000000007FFFFFF ), + UINT64_C( 0x0000000003FFFFFF ), + UINT64_C( 0x0000000001FFFFFF ), + UINT64_C( 0x0000000000FFFFFF ), + UINT64_C( 0x00000000007FFFFF ), + UINT64_C( 0x00000000003FFFFF ), + UINT64_C( 0x00000000001FFFFF ), + UINT64_C( 0x00000000000FFFFF ), + UINT64_C( 0x000000000007FFFF ), + UINT64_C( 0x000000000003FFFF ), + UINT64_C( 0x000000000001FFFF ), + UINT64_C( 0x000000000000FFFF ), + UINT64_C( 0x0000000000007FFF ), + UINT64_C( 0x0000000000003FFF ), + UINT64_C( 0x0000000000001FFF ), + UINT64_C( 0x0000000000000FFF ), + UINT64_C( 0x00000000000007FF ), + UINT64_C( 0x00000000000003FF ), + UINT64_C( 0x00000000000001FF ), + UINT64_C( 0x00000000000000FF ), + UINT64_C( 0x000000000000007F ), + UINT64_C( 0x000000000000003F ), + UINT64_C( 0x000000000000001F ), + UINT64_C( 0x000000000000000F ), + UINT64_C( 0x0000000000000007 ), + UINT64_C( 0x0000000000000003 ) +}; + +static const uint_fast64_t f64NumQInP1 = f64NumQIn * f64NumP1; +static const uint_fast64_t f64NumQOutP1 = f64NumQOut * f64NumP1; + +static float64_t f64NextQInP1( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui64_f64 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f64QIn[expNum] | f64P1[sigNum]; + ++sigNum; + if ( f64NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f64NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float64_t f64NextQOutP1( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui64_f64 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f64QOut[expNum] | f64P1[sigNum]; + ++sigNum; + if ( f64NumP1 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f64NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static const uint_fast64_t f64NumQInP2 = f64NumQIn * f64NumP2; +static const uint_fast64_t f64NumQOutP2 = f64NumQOut * f64NumP2; + +static float64_t f64NextQInP2( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui64_f64 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f64QIn[expNum] | f64P2[sigNum]; + ++sigNum; + if ( f64NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f64NumQIn <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float64_t f64NextQOutP2( struct sequence *sequencePtr ) +{ + int expNum, sigNum; + union ui64_f64 uZ; + + expNum = sequencePtr->expNum; + sigNum = sequencePtr->term1Num; + uZ.ui = f64QOut[expNum] | f64P2[sigNum]; + ++sigNum; + if ( f64NumP2 <= sigNum ) { + sigNum = 0; + ++expNum; + if ( f64NumQOut <= expNum ) { + expNum = 0; + sequencePtr->done = true; + } + sequencePtr->expNum = expNum; + } + sequencePtr->term1Num = sigNum; + return uZ.f; + +} + +static float64_t f64RandomQOutP3( void ) +{ + union ui64_f64 uZ; + + uZ.ui = + f64QOut[randomN_ui8( f64NumQOut )] + | ((f64P2[randomN_ui8( f64NumP2 )] + f64P2[randomN_ui8( f64NumP2 )]) + & UINT64_C( 0x000FFFFFFFFFFFFF )); + return uZ.f; + +} + +static float64_t f64RandomQOutPInf( void ) +{ + union ui64_f64 uZ; + + uZ.ui = + f64QOut[randomN_ui8( f64NumQOut )] + | (random_ui64() & UINT64_C( 0x000FFFFFFFFFFFFF )); + return uZ.f; + +} + +enum { f64NumQInfWeightMasks = 10 }; +static const uint64_t f64QInfWeightMasks[f64NumQInfWeightMasks] = { + UINT64_C( 0xFFF0000000000000 ), + UINT64_C( 0xFFF0000000000000 ), + UINT64_C( 0xBFF0000000000000 ), + UINT64_C( 0x9FF0000000000000 ), + UINT64_C( 0x8FF0000000000000 ), + UINT64_C( 0x87F0000000000000 ), + UINT64_C( 0x83F0000000000000 ), + UINT64_C( 0x81F0000000000000 ), + UINT64_C( 0x80F0000000000000 ), + UINT64_C( 0x8070000000000000 ) +}; +static const uint64_t f64QInfWeightOffsets[f64NumQInfWeightMasks] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x2000000000000000 ), + UINT64_C( 0x3000000000000000 ), + UINT64_C( 0x3800000000000000 ), + UINT64_C( 0x3C00000000000000 ), + UINT64_C( 0x3E00000000000000 ), + UINT64_C( 0x3F00000000000000 ), + UINT64_C( 0x3F80000000000000 ), + UINT64_C( 0x3FC0000000000000 ) +}; + +static float64_t f64RandomQInfP3( void ) +{ + int weightMaskNum; + union ui64_f64 uZ; + + weightMaskNum = randomN_ui8( f64NumQInfWeightMasks ); + uZ.ui = + (((uint_fast64_t) random_ui16()<<48 + & f64QInfWeightMasks[weightMaskNum]) + + f64QInfWeightOffsets[weightMaskNum]) + | ((f64P2[randomN_ui8( f64NumP2 )] + f64P2[randomN_ui8( f64NumP2 )]) + & UINT64_C( 0x000FFFFFFFFFFFFF )); + return uZ.f; + +} + +static float64_t f64RandomQInfPInf( void ) +{ + int weightMaskNum; + union ui64_f64 uZ; + + weightMaskNum = randomN_ui8( f64NumQInfWeightMasks ); + uZ.ui = + (random_ui64() + & (f64QInfWeightMasks[weightMaskNum] + | UINT64_C( 0x000FFFFFFFFFFFFF ))) + + f64QInfWeightOffsets[weightMaskNum]; + return uZ.f; + +} + +static float64_t f64Random( void ) +{ + + switch ( random_ui8() & 7 ) { + case 0: + case 1: + case 2: + return f64RandomQOutP3(); + case 3: + return f64RandomQOutPInf(); + case 4: + case 5: + case 6: + return f64RandomQInfP3(); + case 7: + return f64RandomQInfPInf(); + } + +} + +static struct sequence sequenceA, sequenceB, sequenceC; +static float64_t currentA, currentB, currentC; +static int subcase; + +float64_t genCases_f64_a, genCases_f64_b, genCases_f64_c; + +void genCases_f64_a_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = + (genCases_level == 1) ? 3 * f64NumQOutP1 : 2 * f64NumQOutP2; + genCases_done = false; + +} + +void genCases_f64_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + case 1: + genCases_f64_a = f64Random(); + break; + case 2: + genCases_f64_a = f64NextQOutP1( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f64_a = f64Random(); + break; + case 1: + genCases_f64_a = f64NextQOutP2( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f64_ab_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 6 * f64NumQInP1 * f64NumQInP1; + currentA = f64NextQInP1( &sequenceA ); + } else { + genCases_total = 2 * f64NumQInP2 * f64NumQInP2; + currentA = f64NextQInP2( &sequenceA ); + } + genCases_done = false; + +} + +void genCases_f64_ab_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f64NextQInP1( &sequenceA ); + } + currentB = f64NextQInP1( &sequenceB ); + case 2: + case 4: + genCases_f64_a = f64Random(); + genCases_f64_b = f64Random(); + break; + case 1: + genCases_f64_a = currentA; + genCases_f64_b = f64Random(); + break; + case 3: + genCases_f64_a = f64Random(); + genCases_f64_b = currentB; + break; + case 5: + genCases_f64_a = currentA; + genCases_f64_b = currentB; + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f64_a = f64Random(); + genCases_f64_b = f64Random(); + break; + case 1: + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f64NextQInP2( &sequenceA ); + } + genCases_f64_a = currentA; + genCases_f64_b = f64NextQInP2( &sequenceB ); + genCases_done = sequenceA.done & sequenceB.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +void genCases_f64_abc_init( void ) +{ + + sequenceA.expNum = 0; + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + sequenceB.expNum = 0; + sequenceB.term1Num = 0; + sequenceB.term2Num = 0; + sequenceB.done = false; + sequenceC.expNum = 0; + sequenceC.term1Num = 0; + sequenceC.term2Num = 0; + sequenceC.done = false; + subcase = 0; + if ( genCases_level == 1 ) { + genCases_total = 9 * f64NumQInP1 * f64NumQInP1 * f64NumQInP1; + currentA = f64NextQInP1( &sequenceA ); + currentB = f64NextQInP1( &sequenceB ); + } else { + genCases_total = 2 * f64NumQInP2 * f64NumQInP2 * f64NumQInP2; + currentA = f64NextQInP2( &sequenceA ); + currentB = f64NextQInP2( &sequenceB ); + } + genCases_done = false; + +} + +void genCases_f64_abc_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f64NextQInP1( &sequenceA ); + } + currentB = f64NextQInP1( &sequenceB ); + } + currentC = f64NextQInP1( &sequenceC ); + genCases_f64_a = f64Random(); + genCases_f64_b = f64Random(); + genCases_f64_c = currentC; + break; + case 1: + genCases_f64_a = currentA; + genCases_f64_b = currentB; + genCases_f64_c = f64Random(); + break; + case 2: + genCases_f64_a = f64Random(); + genCases_f64_b = f64Random(); + genCases_f64_c = f64Random(); + break; + case 3: + genCases_f64_a = f64Random(); + genCases_f64_b = currentB; + genCases_f64_c = currentC; + break; + case 4: + genCases_f64_a = currentA; + genCases_f64_b = f64Random(); + genCases_f64_c = f64Random(); + break; + case 5: + genCases_f64_a = f64Random(); + genCases_f64_b = currentB; + genCases_f64_c = f64Random(); + break; + case 6: + genCases_f64_a = currentA; + genCases_f64_b = f64Random(); + genCases_f64_c = currentC; + break; + case 7: + genCases_f64_a = f64Random(); + genCases_f64_b = f64Random(); + genCases_f64_c = f64Random(); + break; + case 8: + genCases_f64_a = currentA; + genCases_f64_b = currentB; + genCases_f64_c = currentC; + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_f64_a = f64Random(); + genCases_f64_b = f64Random(); + genCases_f64_c = f64Random(); + break; + case 1: + if ( sequenceC.done ) { + sequenceC.done = false; + if ( sequenceB.done ) { + sequenceB.done = false; + currentA = f64NextQInP2( &sequenceA ); + } + currentB = f64NextQInP2( &sequenceB ); + } + genCases_f64_a = currentA; + genCases_f64_b = currentB; + genCases_f64_c = f64NextQInP2( &sequenceC ); + genCases_done = sequenceA.done & sequenceB.done & sequenceC.done; + subcase = -1; + break; + } + } + ++subcase; + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i32.c new file mode 100644 index 000000000..6a2fcad68 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i32.c @@ -0,0 +1,362 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "genCases.h" + +struct sequence { + int term1Num, term2Num; + bool done; +}; + +union ui32_i32 { uint32_t ui; int32_t i; }; + +enum { i32NumP1 = 124 }; +static const uint32_t i32P1[i32NumP1] = { + 0x00000000, + 0x00000001, + 0x00000002, + 0x00000004, + 0x00000008, + 0x00000010, + 0x00000020, + 0x00000040, + 0x00000080, + 0x00000100, + 0x00000200, + 0x00000400, + 0x00000800, + 0x00001000, + 0x00002000, + 0x00004000, + 0x00008000, + 0x00010000, + 0x00020000, + 0x00040000, + 0x00080000, + 0x00100000, + 0x00200000, + 0x00400000, + 0x00800000, + 0x01000000, + 0x02000000, + 0x04000000, + 0x08000000, + 0x10000000, + 0x20000000, + 0x40000000, + 0x80000000, + 0xC0000000, + 0xE0000000, + 0xF0000000, + 0xF8000000, + 0xFC000000, + 0xFE000000, + 0xFF000000, + 0xFF800000, + 0xFFC00000, + 0xFFE00000, + 0xFFF00000, + 0xFFF80000, + 0xFFFC0000, + 0xFFFE0000, + 0xFFFF0000, + 0xFFFF8000, + 0xFFFFC000, + 0xFFFFE000, + 0xFFFFF000, + 0xFFFFF800, + 0xFFFFFC00, + 0xFFFFFE00, + 0xFFFFFF00, + 0xFFFFFF80, + 0xFFFFFFC0, + 0xFFFFFFE0, + 0xFFFFFFF0, + 0xFFFFFFF8, + 0xFFFFFFFC, + 0xFFFFFFFE, + 0xFFFFFFFF, + 0xFFFFFFFD, + 0xFFFFFFFB, + 0xFFFFFFF7, + 0xFFFFFFEF, + 0xFFFFFFDF, + 0xFFFFFFBF, + 0xFFFFFF7F, + 0xFFFFFEFF, + 0xFFFFFDFF, + 0xFFFFFBFF, + 0xFFFFF7FF, + 0xFFFFEFFF, + 0xFFFFDFFF, + 0xFFFFBFFF, + 0xFFFF7FFF, + 0xFFFEFFFF, + 0xFFFDFFFF, + 0xFFFBFFFF, + 0xFFF7FFFF, + 0xFFEFFFFF, + 0xFFDFFFFF, + 0xFFBFFFFF, + 0xFF7FFFFF, + 0xFEFFFFFF, + 0xFDFFFFFF, + 0xFBFFFFFF, + 0xF7FFFFFF, + 0xEFFFFFFF, + 0xDFFFFFFF, + 0xBFFFFFFF, + 0x7FFFFFFF, + 0x3FFFFFFF, + 0x1FFFFFFF, + 0x0FFFFFFF, + 0x07FFFFFF, + 0x03FFFFFF, + 0x01FFFFFF, + 0x00FFFFFF, + 0x007FFFFF, + 0x003FFFFF, + 0x001FFFFF, + 0x000FFFFF, + 0x0007FFFF, + 0x0003FFFF, + 0x0001FFFF, + 0x0000FFFF, + 0x00007FFF, + 0x00003FFF, + 0x00001FFF, + 0x00000FFF, + 0x000007FF, + 0x000003FF, + 0x000001FF, + 0x000000FF, + 0x0000007F, + 0x0000003F, + 0x0000001F, + 0x0000000F, + 0x00000007, + 0x00000003 +}; + +static int32_t i32NextP1( struct sequence *sequencePtr ) +{ + int termNum; + union ui32_i32 uZ; + + termNum = sequencePtr->term1Num; + uZ.ui = i32P1[termNum]; + ++termNum; + if ( i32NumP1 <= termNum ) { + termNum = 0; + sequencePtr->done = true; + } + sequencePtr->term1Num = termNum; + return uZ.i; + +} + +static const int_fast32_t i32NumP2 = (i32NumP1 * i32NumP1 + i32NumP1) / 2; + +static int32_t i32NextP2( struct sequence *sequencePtr ) +{ + int term1Num, term2Num; + union ui32_i32 uZ; + + term2Num = sequencePtr->term2Num; + term1Num = sequencePtr->term1Num; + uZ.ui = i32P1[term1Num] + i32P1[term2Num]; + ++term2Num; + if ( i32NumP1 <= term2Num ) { + ++term1Num; + if ( i32NumP1 <= term1Num ) { + term1Num = 0; + sequencePtr->done = true; + } + term2Num = term1Num; + sequencePtr->term1Num = term1Num; + } + sequencePtr->term2Num = term2Num; + return uZ.i; + +} + +static int32_t i32RandomP3( void ) +{ + union ui32_i32 uZ; + + uZ.ui = + i32P1[randomN_ui8( i32NumP1 )] + i32P1[randomN_ui8( i32NumP1 )] + + i32P1[randomN_ui8( i32NumP1 )]; + return uZ.i; + +} + +enum { i32NumPInfWeightMasks = 29 }; +static const uint32_t i32PInfWeightMasks[i32NumPInfWeightMasks] = { + 0xFFFFFFFF, + 0x7FFFFFFF, + 0x3FFFFFFF, + 0x1FFFFFFF, + 0x0FFFFFFF, + 0x07FFFFFF, + 0x03FFFFFF, + 0x01FFFFFF, + 0x00FFFFFF, + 0x007FFFFF, + 0x003FFFFF, + 0x001FFFFF, + 0x000FFFFF, + 0x0007FFFF, + 0x0003FFFF, + 0x0001FFFF, + 0x0000FFFF, + 0x00007FFF, + 0x00003FFF, + 0x00001FFF, + 0x00000FFF, + 0x000007FF, + 0x000003FF, + 0x000001FF, + 0x000000FF, + 0x0000007F, + 0x0000003F, + 0x0000001F, + 0x0000000F +}; +static const uint32_t i32PInfWeightOffsets[i32NumPInfWeightMasks] = { + 0x00000000, + 0xC0000000, + 0xE0000000, + 0xF0000000, + 0xF8000000, + 0xFC000000, + 0xFE000000, + 0xFF000000, + 0xFF800000, + 0xFFC00000, + 0xFFE00000, + 0xFFF00000, + 0xFFF80000, + 0xFFFC0000, + 0xFFFE0000, + 0xFFFF0000, + 0xFFFF8000, + 0xFFFFC000, + 0xFFFFE000, + 0xFFFFF000, + 0xFFFFF800, + 0xFFFFFC00, + 0xFFFFFE00, + 0xFFFFFF00, + 0xFFFFFF80, + 0xFFFFFFC0, + 0xFFFFFFE0, + 0xFFFFFFF0, + 0xFFFFFFF8 +}; + +static int32_t i32RandomPInf( void ) +{ + int weightMaskNum; + union ui32_i32 uZ; + + weightMaskNum = randomN_ui8( i32NumPInfWeightMasks ); + uZ.ui = + (random_ui32() & i32PInfWeightMasks[weightMaskNum]) + + i32PInfWeightOffsets[weightMaskNum]; + return uZ.i; + +} + +static struct sequence sequenceA; +static int subcase; + +int32_t genCases_i32_a; + +void genCases_i32_a_init( void ) +{ + + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = (genCases_level == 1) ? 3 * i32NumP1 : 2 * i32NumP2; + genCases_done = false; + +} + +void genCases_i32_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + genCases_i32_a = i32RandomP3(); + break; + case 1: + genCases_i32_a = i32RandomPInf(); + break; + case 2: + genCases_i32_a = i32NextP1( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_i32_a = i32RandomP3(); + break; + case 2: + genCases_i32_a = i32RandomPInf(); + break; + case 3: + subcase = -1; + case 1: + genCases_i32_a = i32NextP2( &sequenceA ); + genCases_done = sequenceA.done; + break; + } + } + ++subcase; + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i64.c new file mode 100644 index 000000000..82ff7236e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_i64.c @@ -0,0 +1,554 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "genCases.h" + +struct sequence { + int term1Num, term2Num; + bool done; +}; + +union ui64_i64 { uint64_t ui; int64_t i; }; + +enum { i64NumP1 = 252 }; +static const uint64_t i64P1[i64NumP1] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000001 ), + UINT64_C( 0x0000000000000002 ), + UINT64_C( 0x0000000000000004 ), + UINT64_C( 0x0000000000000008 ), + UINT64_C( 0x0000000000000010 ), + UINT64_C( 0x0000000000000020 ), + UINT64_C( 0x0000000000000040 ), + UINT64_C( 0x0000000000000080 ), + UINT64_C( 0x0000000000000100 ), + UINT64_C( 0x0000000000000200 ), + UINT64_C( 0x0000000000000400 ), + UINT64_C( 0x0000000000000800 ), + UINT64_C( 0x0000000000001000 ), + UINT64_C( 0x0000000000002000 ), + UINT64_C( 0x0000000000004000 ), + UINT64_C( 0x0000000000008000 ), + UINT64_C( 0x0000000000010000 ), + UINT64_C( 0x0000000000020000 ), + UINT64_C( 0x0000000000040000 ), + UINT64_C( 0x0000000000080000 ), + UINT64_C( 0x0000000000100000 ), + UINT64_C( 0x0000000000200000 ), + UINT64_C( 0x0000000000400000 ), + UINT64_C( 0x0000000000800000 ), + UINT64_C( 0x0000000001000000 ), + UINT64_C( 0x0000000002000000 ), + UINT64_C( 0x0000000004000000 ), + UINT64_C( 0x0000000008000000 ), + UINT64_C( 0x0000000010000000 ), + UINT64_C( 0x0000000020000000 ), + UINT64_C( 0x0000000040000000 ), + UINT64_C( 0x0000000080000000 ), + UINT64_C( 0x0000000100000000 ), + UINT64_C( 0x0000000200000000 ), + UINT64_C( 0x0000000400000000 ), + UINT64_C( 0x0000000800000000 ), + UINT64_C( 0x0000001000000000 ), + UINT64_C( 0x0000002000000000 ), + UINT64_C( 0x0000004000000000 ), + UINT64_C( 0x0000008000000000 ), + UINT64_C( 0x0000010000000000 ), + UINT64_C( 0x0000020000000000 ), + UINT64_C( 0x0000040000000000 ), + UINT64_C( 0x0000080000000000 ), + UINT64_C( 0x0000100000000000 ), + UINT64_C( 0x0000200000000000 ), + UINT64_C( 0x0000400000000000 ), + UINT64_C( 0x0000800000000000 ), + UINT64_C( 0x0001000000000000 ), + UINT64_C( 0x0002000000000000 ), + UINT64_C( 0x0004000000000000 ), + UINT64_C( 0x0008000000000000 ), + UINT64_C( 0x0010000000000000 ), + UINT64_C( 0x0020000000000000 ), + UINT64_C( 0x0040000000000000 ), + UINT64_C( 0x0080000000000000 ), + UINT64_C( 0x0100000000000000 ), + UINT64_C( 0x0200000000000000 ), + UINT64_C( 0x0400000000000000 ), + UINT64_C( 0x0800000000000000 ), + UINT64_C( 0x1000000000000000 ), + UINT64_C( 0x2000000000000000 ), + UINT64_C( 0x4000000000000000 ), + UINT64_C( 0x8000000000000000 ), + UINT64_C( 0xC000000000000000 ), + UINT64_C( 0xE000000000000000 ), + UINT64_C( 0xF000000000000000 ), + UINT64_C( 0xF800000000000000 ), + UINT64_C( 0xFC00000000000000 ), + UINT64_C( 0xFE00000000000000 ), + UINT64_C( 0xFF00000000000000 ), + UINT64_C( 0xFF80000000000000 ), + UINT64_C( 0xFFC0000000000000 ), + UINT64_C( 0xFFE0000000000000 ), + UINT64_C( 0xFFF0000000000000 ), + UINT64_C( 0xFFF8000000000000 ), + UINT64_C( 0xFFFC000000000000 ), + UINT64_C( 0xFFFE000000000000 ), + UINT64_C( 0xFFFF000000000000 ), + UINT64_C( 0xFFFF800000000000 ), + UINT64_C( 0xFFFFC00000000000 ), + UINT64_C( 0xFFFFE00000000000 ), + UINT64_C( 0xFFFFF00000000000 ), + UINT64_C( 0xFFFFF80000000000 ), + UINT64_C( 0xFFFFFC0000000000 ), + UINT64_C( 0xFFFFFE0000000000 ), + UINT64_C( 0xFFFFFF0000000000 ), + UINT64_C( 0xFFFFFF8000000000 ), + UINT64_C( 0xFFFFFFC000000000 ), + UINT64_C( 0xFFFFFFE000000000 ), + UINT64_C( 0xFFFFFFF000000000 ), + UINT64_C( 0xFFFFFFF800000000 ), + UINT64_C( 0xFFFFFFFC00000000 ), + UINT64_C( 0xFFFFFFFE00000000 ), + UINT64_C( 0xFFFFFFFF00000000 ), + UINT64_C( 0xFFFFFFFF80000000 ), + UINT64_C( 0xFFFFFFFFC0000000 ), + UINT64_C( 0xFFFFFFFFE0000000 ), + UINT64_C( 0xFFFFFFFFF0000000 ), + UINT64_C( 0xFFFFFFFFF8000000 ), + UINT64_C( 0xFFFFFFFFFC000000 ), + UINT64_C( 0xFFFFFFFFFE000000 ), + UINT64_C( 0xFFFFFFFFFF000000 ), + UINT64_C( 0xFFFFFFFFFF800000 ), + UINT64_C( 0xFFFFFFFFFFC00000 ), + UINT64_C( 0xFFFFFFFFFFE00000 ), + UINT64_C( 0xFFFFFFFFFFF00000 ), + UINT64_C( 0xFFFFFFFFFFF80000 ), + UINT64_C( 0xFFFFFFFFFFFC0000 ), + UINT64_C( 0xFFFFFFFFFFFE0000 ), + UINT64_C( 0xFFFFFFFFFFFF0000 ), + UINT64_C( 0xFFFFFFFFFFFF8000 ), + UINT64_C( 0xFFFFFFFFFFFFC000 ), + UINT64_C( 0xFFFFFFFFFFFFE000 ), + UINT64_C( 0xFFFFFFFFFFFFF000 ), + UINT64_C( 0xFFFFFFFFFFFFF800 ), + UINT64_C( 0xFFFFFFFFFFFFFC00 ), + UINT64_C( 0xFFFFFFFFFFFFFE00 ), + UINT64_C( 0xFFFFFFFFFFFFFF00 ), + UINT64_C( 0xFFFFFFFFFFFFFF80 ), + UINT64_C( 0xFFFFFFFFFFFFFFC0 ), + UINT64_C( 0xFFFFFFFFFFFFFFE0 ), + UINT64_C( 0xFFFFFFFFFFFFFFF0 ), + UINT64_C( 0xFFFFFFFFFFFFFFF8 ), + UINT64_C( 0xFFFFFFFFFFFFFFFC ), + UINT64_C( 0xFFFFFFFFFFFFFFFE ), + UINT64_C( 0xFFFFFFFFFFFFFFFF ), + UINT64_C( 0xFFFFFFFFFFFFFFFD ), + UINT64_C( 0xFFFFFFFFFFFFFFFB ), + UINT64_C( 0xFFFFFFFFFFFFFFF7 ), + UINT64_C( 0xFFFFFFFFFFFFFFEF ), + UINT64_C( 0xFFFFFFFFFFFFFFDF ), + UINT64_C( 0xFFFFFFFFFFFFFFBF ), + UINT64_C( 0xFFFFFFFFFFFFFF7F ), + UINT64_C( 0xFFFFFFFFFFFFFEFF ), + UINT64_C( 0xFFFFFFFFFFFFFDFF ), + UINT64_C( 0xFFFFFFFFFFFFFBFF ), + UINT64_C( 0xFFFFFFFFFFFFF7FF ), + UINT64_C( 0xFFFFFFFFFFFFEFFF ), + UINT64_C( 0xFFFFFFFFFFFFDFFF ), + UINT64_C( 0xFFFFFFFFFFFFBFFF ), + UINT64_C( 0xFFFFFFFFFFFF7FFF ), + UINT64_C( 0xFFFFFFFFFFFEFFFF ), + UINT64_C( 0xFFFFFFFFFFFDFFFF ), + UINT64_C( 0xFFFFFFFFFFFBFFFF ), + UINT64_C( 0xFFFFFFFFFFF7FFFF ), + UINT64_C( 0xFFFFFFFFFFEFFFFF ), + UINT64_C( 0xFFFFFFFFFFDFFFFF ), + UINT64_C( 0xFFFFFFFFFFBFFFFF ), + UINT64_C( 0xFFFFFFFFFF7FFFFF ), + UINT64_C( 0xFFFFFFFFFEFFFFFF ), + UINT64_C( 0xFFFFFFFFFDFFFFFF ), + UINT64_C( 0xFFFFFFFFFBFFFFFF ), + UINT64_C( 0xFFFFFFFFF7FFFFFF ), + UINT64_C( 0xFFFFFFFFEFFFFFFF ), + UINT64_C( 0xFFFFFFFFDFFFFFFF ), + UINT64_C( 0xFFFFFFFFBFFFFFFF ), + UINT64_C( 0xFFFFFFFF7FFFFFFF ), + UINT64_C( 0xFFFFFFFEFFFFFFFF ), + UINT64_C( 0xFFFFFFFDFFFFFFFF ), + UINT64_C( 0xFFFFFFFBFFFFFFFF ), + UINT64_C( 0xFFFFFFF7FFFFFFFF ), + UINT64_C( 0xFFFFFFEFFFFFFFFF ), + UINT64_C( 0xFFFFFFDFFFFFFFFF ), + UINT64_C( 0xFFFFFFBFFFFFFFFF ), + UINT64_C( 0xFFFFFF7FFFFFFFFF ), + UINT64_C( 0xFFFFFEFFFFFFFFFF ), + UINT64_C( 0xFFFFFDFFFFFFFFFF ), + UINT64_C( 0xFFFFFBFFFFFFFFFF ), + UINT64_C( 0xFFFFF7FFFFFFFFFF ), + UINT64_C( 0xFFFFEFFFFFFFFFFF ), + UINT64_C( 0xFFFFDFFFFFFFFFFF ), + UINT64_C( 0xFFFFBFFFFFFFFFFF ), + UINT64_C( 0xFFFF7FFFFFFFFFFF ), + UINT64_C( 0xFFFEFFFFFFFFFFFF ), + UINT64_C( 0xFFFDFFFFFFFFFFFF ), + UINT64_C( 0xFFFBFFFFFFFFFFFF ), + UINT64_C( 0xFFF7FFFFFFFFFFFF ), + UINT64_C( 0xFFEFFFFFFFFFFFFF ), + UINT64_C( 0xFFDFFFFFFFFFFFFF ), + UINT64_C( 0xFFBFFFFFFFFFFFFF ), + UINT64_C( 0xFF7FFFFFFFFFFFFF ), + UINT64_C( 0xFEFFFFFFFFFFFFFF ), + UINT64_C( 0xFDFFFFFFFFFFFFFF ), + UINT64_C( 0xFBFFFFFFFFFFFFFF ), + UINT64_C( 0xF7FFFFFFFFFFFFFF ), + UINT64_C( 0xEFFFFFFFFFFFFFFF ), + UINT64_C( 0xDFFFFFFFFFFFFFFF ), + UINT64_C( 0xBFFFFFFFFFFFFFFF ), + UINT64_C( 0x7FFFFFFFFFFFFFFF ), + UINT64_C( 0x3FFFFFFFFFFFFFFF ), + UINT64_C( 0x1FFFFFFFFFFFFFFF ), + UINT64_C( 0x0FFFFFFFFFFFFFFF ), + UINT64_C( 0x07FFFFFFFFFFFFFF ), + UINT64_C( 0x03FFFFFFFFFFFFFF ), + UINT64_C( 0x01FFFFFFFFFFFFFF ), + UINT64_C( 0x00FFFFFFFFFFFFFF ), + UINT64_C( 0x007FFFFFFFFFFFFF ), + UINT64_C( 0x003FFFFFFFFFFFFF ), + UINT64_C( 0x001FFFFFFFFFFFFF ), + UINT64_C( 0x000FFFFFFFFFFFFF ), + UINT64_C( 0x0007FFFFFFFFFFFF ), + UINT64_C( 0x0003FFFFFFFFFFFF ), + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0x0000FFFFFFFFFFFF ), + UINT64_C( 0x00007FFFFFFFFFFF ), + UINT64_C( 0x00003FFFFFFFFFFF ), + UINT64_C( 0x00001FFFFFFFFFFF ), + UINT64_C( 0x00000FFFFFFFFFFF ), + UINT64_C( 0x000007FFFFFFFFFF ), + UINT64_C( 0x000003FFFFFFFFFF ), + UINT64_C( 0x000001FFFFFFFFFF ), + UINT64_C( 0x000000FFFFFFFFFF ), + UINT64_C( 0x0000007FFFFFFFFF ), + UINT64_C( 0x0000003FFFFFFFFF ), + UINT64_C( 0x0000001FFFFFFFFF ), + UINT64_C( 0x0000000FFFFFFFFF ), + UINT64_C( 0x00000007FFFFFFFF ), + UINT64_C( 0x00000003FFFFFFFF ), + UINT64_C( 0x00000001FFFFFFFF ), + UINT64_C( 0x00000000FFFFFFFF ), + UINT64_C( 0x000000007FFFFFFF ), + UINT64_C( 0x000000003FFFFFFF ), + UINT64_C( 0x000000001FFFFFFF ), + UINT64_C( 0x000000000FFFFFFF ), + UINT64_C( 0x0000000007FFFFFF ), + UINT64_C( 0x0000000003FFFFFF ), + UINT64_C( 0x0000000001FFFFFF ), + UINT64_C( 0x0000000000FFFFFF ), + UINT64_C( 0x00000000007FFFFF ), + UINT64_C( 0x00000000003FFFFF ), + UINT64_C( 0x00000000001FFFFF ), + UINT64_C( 0x00000000000FFFFF ), + UINT64_C( 0x000000000007FFFF ), + UINT64_C( 0x000000000003FFFF ), + UINT64_C( 0x000000000001FFFF ), + UINT64_C( 0x000000000000FFFF ), + UINT64_C( 0x0000000000007FFF ), + UINT64_C( 0x0000000000003FFF ), + UINT64_C( 0x0000000000001FFF ), + UINT64_C( 0x0000000000000FFF ), + UINT64_C( 0x00000000000007FF ), + UINT64_C( 0x00000000000003FF ), + UINT64_C( 0x00000000000001FF ), + UINT64_C( 0x00000000000000FF ), + UINT64_C( 0x000000000000007F ), + UINT64_C( 0x000000000000003F ), + UINT64_C( 0x000000000000001F ), + UINT64_C( 0x000000000000000F ), + UINT64_C( 0x0000000000000007 ), + UINT64_C( 0x0000000000000003 ) +}; + +static int64_t i64NextP1( struct sequence *sequencePtr ) +{ + int termNum; + union ui64_i64 uZ; + + termNum = sequencePtr->term1Num; + uZ.ui = i64P1[termNum]; + ++termNum; + if ( i64NumP1 <= termNum ) { + termNum = 0; + sequencePtr->done = true; + } + sequencePtr->term1Num = termNum; + return uZ.i; + +} + +static const int_fast64_t i64NumP2 = (i64NumP1 * i64NumP1 + i64NumP1) / 2; + +static int64_t i64NextP2( struct sequence *sequencePtr ) +{ + int term1Num, term2Num; + union ui64_i64 uZ; + + term2Num = sequencePtr->term2Num; + term1Num = sequencePtr->term1Num; + uZ.ui = i64P1[term1Num] + i64P1[term2Num]; + ++term2Num; + if ( i64NumP1 <= term2Num ) { + ++term1Num; + if ( i64NumP1 <= term1Num ) { + term1Num = 0; + sequencePtr->done = true; + } + term2Num = term1Num; + sequencePtr->term1Num = term1Num; + } + sequencePtr->term2Num = term2Num; + return uZ.i; + +} + +static int64_t i64RandomP3( void ) +{ + union ui64_i64 uZ; + + uZ.ui = + i64P1[randomN_ui8( i64NumP1 )] + i64P1[randomN_ui8( i64NumP1 )] + + i64P1[randomN_ui8( i64NumP1 )]; + return uZ.i; + +} + +enum { i64NumPInfWeightMasks = 61 }; +static const uint64_t i64PInfWeightMasks[i64NumPInfWeightMasks] = { + UINT64_C( 0xFFFFFFFFFFFFFFFF ), + UINT64_C( 0x7FFFFFFFFFFFFFFF ), + UINT64_C( 0x3FFFFFFFFFFFFFFF ), + UINT64_C( 0x1FFFFFFFFFFFFFFF ), + UINT64_C( 0x0FFFFFFFFFFFFFFF ), + UINT64_C( 0x07FFFFFFFFFFFFFF ), + UINT64_C( 0x03FFFFFFFFFFFFFF ), + UINT64_C( 0x01FFFFFFFFFFFFFF ), + UINT64_C( 0x00FFFFFFFFFFFFFF ), + UINT64_C( 0x007FFFFFFFFFFFFF ), + UINT64_C( 0x003FFFFFFFFFFFFF ), + UINT64_C( 0x001FFFFFFFFFFFFF ), + UINT64_C( 0x000FFFFFFFFFFFFF ), + UINT64_C( 0x0007FFFFFFFFFFFF ), + UINT64_C( 0x0003FFFFFFFFFFFF ), + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0x0000FFFFFFFFFFFF ), + UINT64_C( 0x00007FFFFFFFFFFF ), + UINT64_C( 0x00003FFFFFFFFFFF ), + UINT64_C( 0x00001FFFFFFFFFFF ), + UINT64_C( 0x00000FFFFFFFFFFF ), + UINT64_C( 0x000007FFFFFFFFFF ), + UINT64_C( 0x000003FFFFFFFFFF ), + UINT64_C( 0x000001FFFFFFFFFF ), + UINT64_C( 0x000000FFFFFFFFFF ), + UINT64_C( 0x0000007FFFFFFFFF ), + UINT64_C( 0x0000003FFFFFFFFF ), + UINT64_C( 0x0000001FFFFFFFFF ), + UINT64_C( 0x0000000FFFFFFFFF ), + UINT64_C( 0x00000007FFFFFFFF ), + UINT64_C( 0x00000003FFFFFFFF ), + UINT64_C( 0x00000001FFFFFFFF ), + UINT64_C( 0x00000000FFFFFFFF ), + UINT64_C( 0x000000007FFFFFFF ), + UINT64_C( 0x000000003FFFFFFF ), + UINT64_C( 0x000000001FFFFFFF ), + UINT64_C( 0x000000000FFFFFFF ), + UINT64_C( 0x0000000007FFFFFF ), + UINT64_C( 0x0000000003FFFFFF ), + UINT64_C( 0x0000000001FFFFFF ), + UINT64_C( 0x0000000000FFFFFF ), + UINT64_C( 0x00000000007FFFFF ), + UINT64_C( 0x00000000003FFFFF ), + UINT64_C( 0x00000000001FFFFF ), + UINT64_C( 0x00000000000FFFFF ), + UINT64_C( 0x000000000007FFFF ), + UINT64_C( 0x000000000003FFFF ), + UINT64_C( 0x000000000001FFFF ), + UINT64_C( 0x000000000000FFFF ), + UINT64_C( 0x0000000000007FFF ), + UINT64_C( 0x0000000000003FFF ), + UINT64_C( 0x0000000000001FFF ), + UINT64_C( 0x0000000000000FFF ), + UINT64_C( 0x00000000000007FF ), + UINT64_C( 0x00000000000003FF ), + UINT64_C( 0x00000000000001FF ), + UINT64_C( 0x00000000000000FF ), + UINT64_C( 0x000000000000007F ), + UINT64_C( 0x000000000000003F ), + UINT64_C( 0x000000000000001F ), + UINT64_C( 0x000000000000000F ) +}; +static const uint64_t i64PInfWeightOffsets[i64NumPInfWeightMasks] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0xC000000000000000 ), + UINT64_C( 0xE000000000000000 ), + UINT64_C( 0xF000000000000000 ), + UINT64_C( 0xF800000000000000 ), + UINT64_C( 0xFC00000000000000 ), + UINT64_C( 0xFE00000000000000 ), + UINT64_C( 0xFF00000000000000 ), + UINT64_C( 0xFF80000000000000 ), + UINT64_C( 0xFFC0000000000000 ), + UINT64_C( 0xFFE0000000000000 ), + UINT64_C( 0xFFF0000000000000 ), + UINT64_C( 0xFFF8000000000000 ), + UINT64_C( 0xFFFC000000000000 ), + UINT64_C( 0xFFFE000000000000 ), + UINT64_C( 0xFFFF000000000000 ), + UINT64_C( 0xFFFF800000000000 ), + UINT64_C( 0xFFFFC00000000000 ), + UINT64_C( 0xFFFFE00000000000 ), + UINT64_C( 0xFFFFF00000000000 ), + UINT64_C( 0xFFFFF80000000000 ), + UINT64_C( 0xFFFFFC0000000000 ), + UINT64_C( 0xFFFFFE0000000000 ), + UINT64_C( 0xFFFFFF0000000000 ), + UINT64_C( 0xFFFFFF8000000000 ), + UINT64_C( 0xFFFFFFC000000000 ), + UINT64_C( 0xFFFFFFE000000000 ), + UINT64_C( 0xFFFFFFF000000000 ), + UINT64_C( 0xFFFFFFF800000000 ), + UINT64_C( 0xFFFFFFFC00000000 ), + UINT64_C( 0xFFFFFFFE00000000 ), + UINT64_C( 0xFFFFFFFF00000000 ), + UINT64_C( 0xFFFFFFFF80000000 ), + UINT64_C( 0xFFFFFFFFC0000000 ), + UINT64_C( 0xFFFFFFFFE0000000 ), + UINT64_C( 0xFFFFFFFFF0000000 ), + UINT64_C( 0xFFFFFFFFF8000000 ), + UINT64_C( 0xFFFFFFFFFC000000 ), + UINT64_C( 0xFFFFFFFFFE000000 ), + UINT64_C( 0xFFFFFFFFFF000000 ), + UINT64_C( 0xFFFFFFFFFF800000 ), + UINT64_C( 0xFFFFFFFFFFC00000 ), + UINT64_C( 0xFFFFFFFFFFE00000 ), + UINT64_C( 0xFFFFFFFFFFF00000 ), + UINT64_C( 0xFFFFFFFFFFF80000 ), + UINT64_C( 0xFFFFFFFFFFFC0000 ), + UINT64_C( 0xFFFFFFFFFFFE0000 ), + UINT64_C( 0xFFFFFFFFFFFF0000 ), + UINT64_C( 0xFFFFFFFFFFFF8000 ), + UINT64_C( 0xFFFFFFFFFFFFC000 ), + UINT64_C( 0xFFFFFFFFFFFFE000 ), + UINT64_C( 0xFFFFFFFFFFFFF000 ), + UINT64_C( 0xFFFFFFFFFFFFF800 ), + UINT64_C( 0xFFFFFFFFFFFFFC00 ), + UINT64_C( 0xFFFFFFFFFFFFFE00 ), + UINT64_C( 0xFFFFFFFFFFFFFF00 ), + UINT64_C( 0xFFFFFFFFFFFFFF80 ), + UINT64_C( 0xFFFFFFFFFFFFFFC0 ), + UINT64_C( 0xFFFFFFFFFFFFFFE0 ), + UINT64_C( 0xFFFFFFFFFFFFFFF0 ), + UINT64_C( 0xFFFFFFFFFFFFFFF8 ) +}; + +static int64_t i64RandomPInf( void ) +{ + int weightMaskNum; + union ui64_i64 uZ; + + weightMaskNum = randomN_ui8( i64NumPInfWeightMasks ); + uZ.ui = + (random_ui64() & i64PInfWeightMasks[weightMaskNum]) + + i64PInfWeightOffsets[weightMaskNum]; + return uZ.i; + +} + +static struct sequence sequenceA; +static int subcase; + +int64_t genCases_i64_a; + +void genCases_i64_a_init( void ) +{ + + sequenceA.term2Num = 0; + sequenceA.term1Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = (genCases_level == 1) ? 3 * i64NumP1 : 2 * i64NumP2; + genCases_done = false; + +} + +void genCases_i64_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + genCases_i64_a = i64RandomP3(); + break; + case 1: + genCases_i64_a = i64RandomPInf(); + break; + case 2: + genCases_i64_a = i64NextP1( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_i64_a = i64RandomP3(); + break; + case 2: + genCases_i64_a = i64RandomPInf(); + break; + case 3: + subcase = -1; + case 1: + genCases_i64_a = i64NextP2( &sequenceA ); + genCases_done = sequenceA.done; + break; + } + } + ++subcase; + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui32.c new file mode 100644 index 000000000..1298ff6a1 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui32.c @@ -0,0 +1,323 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "genCases.h" + +struct sequence { + int term1Num, term2Num; + bool done; +}; + +enum { ui32NumP1 = 124 }; +static const uint32_t ui32P1[ui32NumP1] = { + 0x00000000, + 0x00000001, + 0x00000002, + 0x00000004, + 0x00000008, + 0x00000010, + 0x00000020, + 0x00000040, + 0x00000080, + 0x00000100, + 0x00000200, + 0x00000400, + 0x00000800, + 0x00001000, + 0x00002000, + 0x00004000, + 0x00008000, + 0x00010000, + 0x00020000, + 0x00040000, + 0x00080000, + 0x00100000, + 0x00200000, + 0x00400000, + 0x00800000, + 0x01000000, + 0x02000000, + 0x04000000, + 0x08000000, + 0x10000000, + 0x20000000, + 0x40000000, + 0x80000000, + 0xC0000000, + 0xE0000000, + 0xF0000000, + 0xF8000000, + 0xFC000000, + 0xFE000000, + 0xFF000000, + 0xFF800000, + 0xFFC00000, + 0xFFE00000, + 0xFFF00000, + 0xFFF80000, + 0xFFFC0000, + 0xFFFE0000, + 0xFFFF0000, + 0xFFFF8000, + 0xFFFFC000, + 0xFFFFE000, + 0xFFFFF000, + 0xFFFFF800, + 0xFFFFFC00, + 0xFFFFFE00, + 0xFFFFFF00, + 0xFFFFFF80, + 0xFFFFFFC0, + 0xFFFFFFE0, + 0xFFFFFFF0, + 0xFFFFFFF8, + 0xFFFFFFFC, + 0xFFFFFFFE, + 0xFFFFFFFF, + 0xFFFFFFFD, + 0xFFFFFFFB, + 0xFFFFFFF7, + 0xFFFFFFEF, + 0xFFFFFFDF, + 0xFFFFFFBF, + 0xFFFFFF7F, + 0xFFFFFEFF, + 0xFFFFFDFF, + 0xFFFFFBFF, + 0xFFFFF7FF, + 0xFFFFEFFF, + 0xFFFFDFFF, + 0xFFFFBFFF, + 0xFFFF7FFF, + 0xFFFEFFFF, + 0xFFFDFFFF, + 0xFFFBFFFF, + 0xFFF7FFFF, + 0xFFEFFFFF, + 0xFFDFFFFF, + 0xFFBFFFFF, + 0xFF7FFFFF, + 0xFEFFFFFF, + 0xFDFFFFFF, + 0xFBFFFFFF, + 0xF7FFFFFF, + 0xEFFFFFFF, + 0xDFFFFFFF, + 0xBFFFFFFF, + 0x7FFFFFFF, + 0x3FFFFFFF, + 0x1FFFFFFF, + 0x0FFFFFFF, + 0x07FFFFFF, + 0x03FFFFFF, + 0x01FFFFFF, + 0x00FFFFFF, + 0x007FFFFF, + 0x003FFFFF, + 0x001FFFFF, + 0x000FFFFF, + 0x0007FFFF, + 0x0003FFFF, + 0x0001FFFF, + 0x0000FFFF, + 0x00007FFF, + 0x00003FFF, + 0x00001FFF, + 0x00000FFF, + 0x000007FF, + 0x000003FF, + 0x000001FF, + 0x000000FF, + 0x0000007F, + 0x0000003F, + 0x0000001F, + 0x0000000F, + 0x00000007, + 0x00000003 +}; + +static uint32_t ui32NextP1( struct sequence *sequencePtr ) +{ + int termNum; + uint32_t z; + + termNum = sequencePtr->term1Num; + z = ui32P1[termNum]; + ++termNum; + if ( ui32NumP1 <= termNum ) { + termNum = 0; + sequencePtr->done = true; + } + sequencePtr->term1Num = termNum; + return z; + +} + +static const uint_fast32_t ui32NumP2 = (ui32NumP1 * ui32NumP1 + ui32NumP1) / 2; + +static uint32_t ui32NextP2( struct sequence *sequencePtr ) +{ + int term1Num, term2Num; + uint32_t z; + + term2Num = sequencePtr->term2Num; + term1Num = sequencePtr->term1Num; + z = ui32P1[term1Num] + ui32P1[term2Num]; + ++term2Num; + if ( ui32NumP1 <= term2Num ) { + ++term1Num; + if ( ui32NumP1 <= term1Num ) { + term1Num = 0; + sequencePtr->done = true; + } + term2Num = term1Num; + sequencePtr->term1Num = term1Num; + } + sequencePtr->term2Num = term2Num; + return z; + +} + +static uint32_t ui32RandomP3( void ) +{ + + return + ui32P1[randomN_ui8( ui32NumP1 )] + ui32P1[randomN_ui8( ui32NumP1 )] + + ui32P1[randomN_ui8( ui32NumP1 )]; + +} + +enum { ui32NumPInfWeightMasks = 29 }; +static const uint32_t ui32PInfWeightMasks[ui32NumPInfWeightMasks] = { + 0xFFFFFFFF, + 0x7FFFFFFF, + 0x3FFFFFFF, + 0x1FFFFFFF, + 0x0FFFFFFF, + 0x07FFFFFF, + 0x03FFFFFF, + 0x01FFFFFF, + 0x00FFFFFF, + 0x007FFFFF, + 0x003FFFFF, + 0x001FFFFF, + 0x000FFFFF, + 0x0007FFFF, + 0x0003FFFF, + 0x0001FFFF, + 0x0000FFFF, + 0x00007FFF, + 0x00003FFF, + 0x00001FFF, + 0x00000FFF, + 0x000007FF, + 0x000003FF, + 0x000001FF, + 0x000000FF, + 0x0000007F, + 0x0000003F, + 0x0000001F, + 0x0000000F +}; + +static uint32_t ui32RandomPInf( void ) +{ + int weightMaskNum; + + weightMaskNum = randomN_ui8( ui32NumPInfWeightMasks ); + return random_ui32() & ui32PInfWeightMasks[weightMaskNum]; + +} + +static struct sequence sequenceA; +static int subcase; + +uint32_t genCases_ui32_a; + +void genCases_ui32_a_init( void ) +{ + + sequenceA.term1Num = 0; + sequenceA.term2Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = (genCases_level == 1) ? 3 * ui32NumP1 : 2 * ui32NumP2; + genCases_done = false; + +} + +void genCases_ui32_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + genCases_ui32_a = ui32RandomP3(); + break; + case 1: + genCases_ui32_a = ui32RandomPInf(); + break; + case 2: + genCases_ui32_a = ui32NextP1( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_ui32_a = ui32RandomP3(); + break; + case 2: + genCases_ui32_a = ui32RandomPInf(); + break; + case 3: + subcase = -1; + case 1: + genCases_ui32_a = ui32NextP2( &sequenceA ); + genCases_done = sequenceA.done; + break; + } + } + ++subcase; + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui64.c new file mode 100644 index 000000000..42d44a467 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_ui64.c @@ -0,0 +1,483 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" +#include "genCases.h" + +struct sequence { + int term1Num, term2Num; + bool done; +}; + +enum { ui64NumP1 = 252 }; +static const uint64_t ui64P1[ui64NumP1] = { + UINT64_C( 0x0000000000000000 ), + UINT64_C( 0x0000000000000001 ), + UINT64_C( 0x0000000000000002 ), + UINT64_C( 0x0000000000000004 ), + UINT64_C( 0x0000000000000008 ), + UINT64_C( 0x0000000000000010 ), + UINT64_C( 0x0000000000000020 ), + UINT64_C( 0x0000000000000040 ), + UINT64_C( 0x0000000000000080 ), + UINT64_C( 0x0000000000000100 ), + UINT64_C( 0x0000000000000200 ), + UINT64_C( 0x0000000000000400 ), + UINT64_C( 0x0000000000000800 ), + UINT64_C( 0x0000000000001000 ), + UINT64_C( 0x0000000000002000 ), + UINT64_C( 0x0000000000004000 ), + UINT64_C( 0x0000000000008000 ), + UINT64_C( 0x0000000000010000 ), + UINT64_C( 0x0000000000020000 ), + UINT64_C( 0x0000000000040000 ), + UINT64_C( 0x0000000000080000 ), + UINT64_C( 0x0000000000100000 ), + UINT64_C( 0x0000000000200000 ), + UINT64_C( 0x0000000000400000 ), + UINT64_C( 0x0000000000800000 ), + UINT64_C( 0x0000000001000000 ), + UINT64_C( 0x0000000002000000 ), + UINT64_C( 0x0000000004000000 ), + UINT64_C( 0x0000000008000000 ), + UINT64_C( 0x0000000010000000 ), + UINT64_C( 0x0000000020000000 ), + UINT64_C( 0x0000000040000000 ), + UINT64_C( 0x0000000080000000 ), + UINT64_C( 0x0000000100000000 ), + UINT64_C( 0x0000000200000000 ), + UINT64_C( 0x0000000400000000 ), + UINT64_C( 0x0000000800000000 ), + UINT64_C( 0x0000001000000000 ), + UINT64_C( 0x0000002000000000 ), + UINT64_C( 0x0000004000000000 ), + UINT64_C( 0x0000008000000000 ), + UINT64_C( 0x0000010000000000 ), + UINT64_C( 0x0000020000000000 ), + UINT64_C( 0x0000040000000000 ), + UINT64_C( 0x0000080000000000 ), + UINT64_C( 0x0000100000000000 ), + UINT64_C( 0x0000200000000000 ), + UINT64_C( 0x0000400000000000 ), + UINT64_C( 0x0000800000000000 ), + UINT64_C( 0x0001000000000000 ), + UINT64_C( 0x0002000000000000 ), + UINT64_C( 0x0004000000000000 ), + UINT64_C( 0x0008000000000000 ), + UINT64_C( 0x0010000000000000 ), + UINT64_C( 0x0020000000000000 ), + UINT64_C( 0x0040000000000000 ), + UINT64_C( 0x0080000000000000 ), + UINT64_C( 0x0100000000000000 ), + UINT64_C( 0x0200000000000000 ), + UINT64_C( 0x0400000000000000 ), + UINT64_C( 0x0800000000000000 ), + UINT64_C( 0x1000000000000000 ), + UINT64_C( 0x2000000000000000 ), + UINT64_C( 0x4000000000000000 ), + UINT64_C( 0x8000000000000000 ), + UINT64_C( 0xC000000000000000 ), + UINT64_C( 0xE000000000000000 ), + UINT64_C( 0xF000000000000000 ), + UINT64_C( 0xF800000000000000 ), + UINT64_C( 0xFC00000000000000 ), + UINT64_C( 0xFE00000000000000 ), + UINT64_C( 0xFF00000000000000 ), + UINT64_C( 0xFF80000000000000 ), + UINT64_C( 0xFFC0000000000000 ), + UINT64_C( 0xFFE0000000000000 ), + UINT64_C( 0xFFF0000000000000 ), + UINT64_C( 0xFFF8000000000000 ), + UINT64_C( 0xFFFC000000000000 ), + UINT64_C( 0xFFFE000000000000 ), + UINT64_C( 0xFFFF000000000000 ), + UINT64_C( 0xFFFF800000000000 ), + UINT64_C( 0xFFFFC00000000000 ), + UINT64_C( 0xFFFFE00000000000 ), + UINT64_C( 0xFFFFF00000000000 ), + UINT64_C( 0xFFFFF80000000000 ), + UINT64_C( 0xFFFFFC0000000000 ), + UINT64_C( 0xFFFFFE0000000000 ), + UINT64_C( 0xFFFFFF0000000000 ), + UINT64_C( 0xFFFFFF8000000000 ), + UINT64_C( 0xFFFFFFC000000000 ), + UINT64_C( 0xFFFFFFE000000000 ), + UINT64_C( 0xFFFFFFF000000000 ), + UINT64_C( 0xFFFFFFF800000000 ), + UINT64_C( 0xFFFFFFFC00000000 ), + UINT64_C( 0xFFFFFFFE00000000 ), + UINT64_C( 0xFFFFFFFF00000000 ), + UINT64_C( 0xFFFFFFFF80000000 ), + UINT64_C( 0xFFFFFFFFC0000000 ), + UINT64_C( 0xFFFFFFFFE0000000 ), + UINT64_C( 0xFFFFFFFFF0000000 ), + UINT64_C( 0xFFFFFFFFF8000000 ), + UINT64_C( 0xFFFFFFFFFC000000 ), + UINT64_C( 0xFFFFFFFFFE000000 ), + UINT64_C( 0xFFFFFFFFFF000000 ), + UINT64_C( 0xFFFFFFFFFF800000 ), + UINT64_C( 0xFFFFFFFFFFC00000 ), + UINT64_C( 0xFFFFFFFFFFE00000 ), + UINT64_C( 0xFFFFFFFFFFF00000 ), + UINT64_C( 0xFFFFFFFFFFF80000 ), + UINT64_C( 0xFFFFFFFFFFFC0000 ), + UINT64_C( 0xFFFFFFFFFFFE0000 ), + UINT64_C( 0xFFFFFFFFFFFF0000 ), + UINT64_C( 0xFFFFFFFFFFFF8000 ), + UINT64_C( 0xFFFFFFFFFFFFC000 ), + UINT64_C( 0xFFFFFFFFFFFFE000 ), + UINT64_C( 0xFFFFFFFFFFFFF000 ), + UINT64_C( 0xFFFFFFFFFFFFF800 ), + UINT64_C( 0xFFFFFFFFFFFFFC00 ), + UINT64_C( 0xFFFFFFFFFFFFFE00 ), + UINT64_C( 0xFFFFFFFFFFFFFF00 ), + UINT64_C( 0xFFFFFFFFFFFFFF80 ), + UINT64_C( 0xFFFFFFFFFFFFFFC0 ), + UINT64_C( 0xFFFFFFFFFFFFFFE0 ), + UINT64_C( 0xFFFFFFFFFFFFFFF0 ), + UINT64_C( 0xFFFFFFFFFFFFFFF8 ), + UINT64_C( 0xFFFFFFFFFFFFFFFC ), + UINT64_C( 0xFFFFFFFFFFFFFFFE ), + UINT64_C( 0xFFFFFFFFFFFFFFFF ), + UINT64_C( 0xFFFFFFFFFFFFFFFD ), + UINT64_C( 0xFFFFFFFFFFFFFFFB ), + UINT64_C( 0xFFFFFFFFFFFFFFF7 ), + UINT64_C( 0xFFFFFFFFFFFFFFEF ), + UINT64_C( 0xFFFFFFFFFFFFFFDF ), + UINT64_C( 0xFFFFFFFFFFFFFFBF ), + UINT64_C( 0xFFFFFFFFFFFFFF7F ), + UINT64_C( 0xFFFFFFFFFFFFFEFF ), + UINT64_C( 0xFFFFFFFFFFFFFDFF ), + UINT64_C( 0xFFFFFFFFFFFFFBFF ), + UINT64_C( 0xFFFFFFFFFFFFF7FF ), + UINT64_C( 0xFFFFFFFFFFFFEFFF ), + UINT64_C( 0xFFFFFFFFFFFFDFFF ), + UINT64_C( 0xFFFFFFFFFFFFBFFF ), + UINT64_C( 0xFFFFFFFFFFFF7FFF ), + UINT64_C( 0xFFFFFFFFFFFEFFFF ), + UINT64_C( 0xFFFFFFFFFFFDFFFF ), + UINT64_C( 0xFFFFFFFFFFFBFFFF ), + UINT64_C( 0xFFFFFFFFFFF7FFFF ), + UINT64_C( 0xFFFFFFFFFFEFFFFF ), + UINT64_C( 0xFFFFFFFFFFDFFFFF ), + UINT64_C( 0xFFFFFFFFFFBFFFFF ), + UINT64_C( 0xFFFFFFFFFF7FFFFF ), + UINT64_C( 0xFFFFFFFFFEFFFFFF ), + UINT64_C( 0xFFFFFFFFFDFFFFFF ), + UINT64_C( 0xFFFFFFFFFBFFFFFF ), + UINT64_C( 0xFFFFFFFFF7FFFFFF ), + UINT64_C( 0xFFFFFFFFEFFFFFFF ), + UINT64_C( 0xFFFFFFFFDFFFFFFF ), + UINT64_C( 0xFFFFFFFFBFFFFFFF ), + UINT64_C( 0xFFFFFFFF7FFFFFFF ), + UINT64_C( 0xFFFFFFFEFFFFFFFF ), + UINT64_C( 0xFFFFFFFDFFFFFFFF ), + UINT64_C( 0xFFFFFFFBFFFFFFFF ), + UINT64_C( 0xFFFFFFF7FFFFFFFF ), + UINT64_C( 0xFFFFFFEFFFFFFFFF ), + UINT64_C( 0xFFFFFFDFFFFFFFFF ), + UINT64_C( 0xFFFFFFBFFFFFFFFF ), + UINT64_C( 0xFFFFFF7FFFFFFFFF ), + UINT64_C( 0xFFFFFEFFFFFFFFFF ), + UINT64_C( 0xFFFFFDFFFFFFFFFF ), + UINT64_C( 0xFFFFFBFFFFFFFFFF ), + UINT64_C( 0xFFFFF7FFFFFFFFFF ), + UINT64_C( 0xFFFFEFFFFFFFFFFF ), + UINT64_C( 0xFFFFDFFFFFFFFFFF ), + UINT64_C( 0xFFFFBFFFFFFFFFFF ), + UINT64_C( 0xFFFF7FFFFFFFFFFF ), + UINT64_C( 0xFFFEFFFFFFFFFFFF ), + UINT64_C( 0xFFFDFFFFFFFFFFFF ), + UINT64_C( 0xFFFBFFFFFFFFFFFF ), + UINT64_C( 0xFFF7FFFFFFFFFFFF ), + UINT64_C( 0xFFEFFFFFFFFFFFFF ), + UINT64_C( 0xFFDFFFFFFFFFFFFF ), + UINT64_C( 0xFFBFFFFFFFFFFFFF ), + UINT64_C( 0xFF7FFFFFFFFFFFFF ), + UINT64_C( 0xFEFFFFFFFFFFFFFF ), + UINT64_C( 0xFDFFFFFFFFFFFFFF ), + UINT64_C( 0xFBFFFFFFFFFFFFFF ), + UINT64_C( 0xF7FFFFFFFFFFFFFF ), + UINT64_C( 0xEFFFFFFFFFFFFFFF ), + UINT64_C( 0xDFFFFFFFFFFFFFFF ), + UINT64_C( 0xBFFFFFFFFFFFFFFF ), + UINT64_C( 0x7FFFFFFFFFFFFFFF ), + UINT64_C( 0x3FFFFFFFFFFFFFFF ), + UINT64_C( 0x1FFFFFFFFFFFFFFF ), + UINT64_C( 0x0FFFFFFFFFFFFFFF ), + UINT64_C( 0x07FFFFFFFFFFFFFF ), + UINT64_C( 0x03FFFFFFFFFFFFFF ), + UINT64_C( 0x01FFFFFFFFFFFFFF ), + UINT64_C( 0x00FFFFFFFFFFFFFF ), + UINT64_C( 0x007FFFFFFFFFFFFF ), + UINT64_C( 0x003FFFFFFFFFFFFF ), + UINT64_C( 0x001FFFFFFFFFFFFF ), + UINT64_C( 0x000FFFFFFFFFFFFF ), + UINT64_C( 0x0007FFFFFFFFFFFF ), + UINT64_C( 0x0003FFFFFFFFFFFF ), + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0x0000FFFFFFFFFFFF ), + UINT64_C( 0x00007FFFFFFFFFFF ), + UINT64_C( 0x00003FFFFFFFFFFF ), + UINT64_C( 0x00001FFFFFFFFFFF ), + UINT64_C( 0x00000FFFFFFFFFFF ), + UINT64_C( 0x000007FFFFFFFFFF ), + UINT64_C( 0x000003FFFFFFFFFF ), + UINT64_C( 0x000001FFFFFFFFFF ), + UINT64_C( 0x000000FFFFFFFFFF ), + UINT64_C( 0x0000007FFFFFFFFF ), + UINT64_C( 0x0000003FFFFFFFFF ), + UINT64_C( 0x0000001FFFFFFFFF ), + UINT64_C( 0x0000000FFFFFFFFF ), + UINT64_C( 0x00000007FFFFFFFF ), + UINT64_C( 0x00000003FFFFFFFF ), + UINT64_C( 0x00000001FFFFFFFF ), + UINT64_C( 0x00000000FFFFFFFF ), + UINT64_C( 0x000000007FFFFFFF ), + UINT64_C( 0x000000003FFFFFFF ), + UINT64_C( 0x000000001FFFFFFF ), + UINT64_C( 0x000000000FFFFFFF ), + UINT64_C( 0x0000000007FFFFFF ), + UINT64_C( 0x0000000003FFFFFF ), + UINT64_C( 0x0000000001FFFFFF ), + UINT64_C( 0x0000000000FFFFFF ), + UINT64_C( 0x00000000007FFFFF ), + UINT64_C( 0x00000000003FFFFF ), + UINT64_C( 0x00000000001FFFFF ), + UINT64_C( 0x00000000000FFFFF ), + UINT64_C( 0x000000000007FFFF ), + UINT64_C( 0x000000000003FFFF ), + UINT64_C( 0x000000000001FFFF ), + UINT64_C( 0x000000000000FFFF ), + UINT64_C( 0x0000000000007FFF ), + UINT64_C( 0x0000000000003FFF ), + UINT64_C( 0x0000000000001FFF ), + UINT64_C( 0x0000000000000FFF ), + UINT64_C( 0x00000000000007FF ), + UINT64_C( 0x00000000000003FF ), + UINT64_C( 0x00000000000001FF ), + UINT64_C( 0x00000000000000FF ), + UINT64_C( 0x000000000000007F ), + UINT64_C( 0x000000000000003F ), + UINT64_C( 0x000000000000001F ), + UINT64_C( 0x000000000000000F ), + UINT64_C( 0x0000000000000007 ), + UINT64_C( 0x0000000000000003 ) +}; + +static uint64_t ui64NextP1( struct sequence *sequencePtr ) +{ + int termNum; + uint64_t z; + + termNum = sequencePtr->term1Num; + z = ui64P1[termNum]; + ++termNum; + if ( ui64NumP1 <= termNum ) { + termNum = 0; + sequencePtr->done = true; + } + sequencePtr->term1Num = termNum; + return z; + +} + +static const uint_fast64_t ui64NumP2 = (ui64NumP1 * ui64NumP1 + ui64NumP1) / 2; + +static uint64_t ui64NextP2( struct sequence *sequencePtr ) +{ + int term1Num, term2Num; + uint64_t z; + + term2Num = sequencePtr->term2Num; + term1Num = sequencePtr->term1Num; + z = ui64P1[term1Num] + ui64P1[term2Num]; + ++term2Num; + if ( ui64NumP1 <= term2Num ) { + ++term1Num; + if ( ui64NumP1 <= term1Num ) { + term1Num = 0; + sequencePtr->done = true; + } + term2Num = term1Num; + sequencePtr->term1Num = term1Num; + } + sequencePtr->term2Num = term2Num; + return z; + +} + +static uint64_t ui64RandomP3( void ) +{ + + return + ui64P1[randomN_ui8( ui64NumP1 )] + ui64P1[randomN_ui8( ui64NumP1 )] + + ui64P1[randomN_ui8( ui64NumP1 )]; + +} + +enum { ui64NumPInfWeightMasks = 61 }; +static const uint64_t ui64PInfWeightMasks[ui64NumPInfWeightMasks] = { + UINT64_C( 0xFFFFFFFFFFFFFFFF ), + UINT64_C( 0x7FFFFFFFFFFFFFFF ), + UINT64_C( 0x3FFFFFFFFFFFFFFF ), + UINT64_C( 0x1FFFFFFFFFFFFFFF ), + UINT64_C( 0x0FFFFFFFFFFFFFFF ), + UINT64_C( 0x07FFFFFFFFFFFFFF ), + UINT64_C( 0x03FFFFFFFFFFFFFF ), + UINT64_C( 0x01FFFFFFFFFFFFFF ), + UINT64_C( 0x00FFFFFFFFFFFFFF ), + UINT64_C( 0x007FFFFFFFFFFFFF ), + UINT64_C( 0x003FFFFFFFFFFFFF ), + UINT64_C( 0x001FFFFFFFFFFFFF ), + UINT64_C( 0x000FFFFFFFFFFFFF ), + UINT64_C( 0x0007FFFFFFFFFFFF ), + UINT64_C( 0x0003FFFFFFFFFFFF ), + UINT64_C( 0x0001FFFFFFFFFFFF ), + UINT64_C( 0x0000FFFFFFFFFFFF ), + UINT64_C( 0x00007FFFFFFFFFFF ), + UINT64_C( 0x00003FFFFFFFFFFF ), + UINT64_C( 0x00001FFFFFFFFFFF ), + UINT64_C( 0x00000FFFFFFFFFFF ), + UINT64_C( 0x000007FFFFFFFFFF ), + UINT64_C( 0x000003FFFFFFFFFF ), + UINT64_C( 0x000001FFFFFFFFFF ), + UINT64_C( 0x000000FFFFFFFFFF ), + UINT64_C( 0x0000007FFFFFFFFF ), + UINT64_C( 0x0000003FFFFFFFFF ), + UINT64_C( 0x0000001FFFFFFFFF ), + UINT64_C( 0x0000000FFFFFFFFF ), + UINT64_C( 0x00000007FFFFFFFF ), + UINT64_C( 0x00000003FFFFFFFF ), + UINT64_C( 0x00000001FFFFFFFF ), + UINT64_C( 0x00000000FFFFFFFF ), + UINT64_C( 0x000000007FFFFFFF ), + UINT64_C( 0x000000003FFFFFFF ), + UINT64_C( 0x000000001FFFFFFF ), + UINT64_C( 0x000000000FFFFFFF ), + UINT64_C( 0x0000000007FFFFFF ), + UINT64_C( 0x0000000003FFFFFF ), + UINT64_C( 0x0000000001FFFFFF ), + UINT64_C( 0x0000000000FFFFFF ), + UINT64_C( 0x00000000007FFFFF ), + UINT64_C( 0x00000000003FFFFF ), + UINT64_C( 0x00000000001FFFFF ), + UINT64_C( 0x00000000000FFFFF ), + UINT64_C( 0x000000000007FFFF ), + UINT64_C( 0x000000000003FFFF ), + UINT64_C( 0x000000000001FFFF ), + UINT64_C( 0x000000000000FFFF ), + UINT64_C( 0x0000000000007FFF ), + UINT64_C( 0x0000000000003FFF ), + UINT64_C( 0x0000000000001FFF ), + UINT64_C( 0x0000000000000FFF ), + UINT64_C( 0x00000000000007FF ), + UINT64_C( 0x00000000000003FF ), + UINT64_C( 0x00000000000001FF ), + UINT64_C( 0x00000000000000FF ), + UINT64_C( 0x000000000000007F ), + UINT64_C( 0x000000000000003F ), + UINT64_C( 0x000000000000001F ), + UINT64_C( 0x000000000000000F ) +}; + +static uint64_t ui64RandomPInf( void ) +{ + int weightMaskNum; + + weightMaskNum = randomN_ui8( ui64NumPInfWeightMasks ); + return random_ui64() & ui64PInfWeightMasks[weightMaskNum]; + +} + +static struct sequence sequenceA; +static int subcase; + +uint64_t genCases_ui64_a; + +void genCases_ui64_a_init( void ) +{ + + sequenceA.term2Num = 0; + sequenceA.term1Num = 0; + sequenceA.done = false; + subcase = 0; + genCases_total = (genCases_level == 1) ? 3 * ui64NumP1 : 2 * ui64NumP2; + genCases_done = false; + +} + +void genCases_ui64_a_next( void ) +{ + + if ( genCases_level == 1 ) { + switch ( subcase ) { + case 0: + genCases_ui64_a = ui64RandomP3(); + break; + case 1: + genCases_ui64_a = ui64RandomPInf(); + break; + case 2: + genCases_ui64_a = ui64NextP1( &sequenceA ); + genCases_done = sequenceA.done; + subcase = -1; + break; + } + } else { + switch ( subcase ) { + case 0: + genCases_ui64_a = ui64RandomP3(); + break; + case 2: + genCases_ui64_a = ui64RandomPInf(); + break; + case 3: + subcase = -1; + case 1: + genCases_ui64_a = ui64NextP2( &sequenceA ); + genCases_done = sequenceA.done; + break; + } + } + ++subcase; + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_writeTestsTotal.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_writeTestsTotal.c new file mode 100644 index 000000000..715a7cc2d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genCases_writeTestsTotal.c @@ -0,0 +1,63 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "genCases.h" + +void genCases_writeTestsTotal( bool forever ) +{ + + if ( forever ) { + fputs( "Unbounded tests.\n", stderr ); + } else { + if ( 2000000000 <= genCases_total ) { + fprintf( + stderr, + "\r%lu%09lu tests total.\n", + (long unsigned) (genCases_total / 1000000000), + (long unsigned) (genCases_total % 1000000000) + ); + } else { + fprintf( + stderr, "\r%lu tests total.\n", (long unsigned) genCases_total + ); + } + } + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.c new file mode 100644 index 000000000..6082fc24e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.c @@ -0,0 +1,2890 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include +#include +#include "platform.h" +#include "uint128.h" +#include "fail.h" +#include "softfloat.h" +#include "genCases.h" +#include "writeHex.h" +#include "genLoops.h" + +volatile sig_atomic_t genLoops_stop = false; + +bool genLoops_forever; +bool genLoops_givenCount; +uint_fast64_t genLoops_count; +uint_fast8_t *genLoops_trueFlagsPtr; + +#ifdef FLOAT16 +union ui16_f16 { uint16_t ui; float16_t f; }; +#endif +union ui32_f32 { uint32_t ui; float32_t f; }; +#ifdef FLOAT64 +union ui64_f64 { uint64_t ui; float64_t f; }; +#endif + +static void checkEnoughCases( void ) +{ + + if ( genLoops_givenCount && (genLoops_count < genCases_total) ) { + if ( 2000000000 <= genCases_total ) { + fail( + "Too few cases; minimum is %lu%09lu", + (unsigned long) (genCases_total / 1000000000), + (unsigned long) (genCases_total % 1000000000) + ); + } else { + fail( + "Too few cases; minimum is %lu", (unsigned long) genCases_total + ); + } + } + +} + +static void writeGenOutput_flags( uint_fast8_t flags ) +{ + uint_fast8_t commonFlags; + + commonFlags = 0; + if ( flags & softfloat_flag_invalid ) commonFlags |= 0x10; + if ( flags & softfloat_flag_infinite ) commonFlags |= 0x08; + if ( flags & softfloat_flag_overflow ) commonFlags |= 0x04; + if ( flags & softfloat_flag_underflow ) commonFlags |= 0x02; + if ( flags & softfloat_flag_inexact ) commonFlags |= 0x01; + writeHex_ui8( commonFlags, '\n' ); + +} + +static bool writeGenOutputs_bool( bool z, uint_fast8_t flags ) +{ + + writeHex_bool( z, ' ' ); + writeGenOutput_flags( flags ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) return true; + } + return false; + +} + +#ifdef FLOAT16 + +static bool writeGenOutputs_ui16( uint_fast16_t z, uint_fast8_t flags ) +{ + + writeHex_ui16( z, ' ' ); + writeGenOutput_flags( flags ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) return true; + } + return false; + +} + +#endif + +static bool writeGenOutputs_ui32( uint_fast32_t z, uint_fast8_t flags ) +{ + + writeHex_ui32( z, ' ' ); + writeGenOutput_flags( flags ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) return true; + } + return false; + +} + +static bool writeGenOutputs_ui64( uint_fast64_t z, uint_fast8_t flags ) +{ + + writeHex_ui64( z, ' ' ); + writeGenOutput_flags( flags ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) return true; + } + return false; + +} + +#ifdef EXTFLOAT80 + +static void writeHex_uiExtF80M( const extFloat80_t *aPtr, char sepChar ) +{ + const struct extFloat80M *aSPtr; + + aSPtr = (const struct extFloat80M *) aPtr; + writeHex_ui16( aSPtr->signExp, 0 ); + writeHex_ui64( aSPtr->signif, sepChar ); + +} + +static +bool writeGenOutputs_extF80M( const extFloat80_t *aPtr, uint_fast8_t flags ) +{ + + writeHex_uiExtF80M( aPtr, ' ' ); + writeGenOutput_flags( flags ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) return true; + } + return false; + +} + +#endif + +#ifdef FLOAT128 + +static void writeHex_uiF128M( const float128_t *aPtr, char sepChar ) +{ + const struct uint128 *uiAPtr; + + uiAPtr = (const struct uint128 *) aPtr; + writeHex_ui64( uiAPtr->v64, 0 ); + writeHex_ui64( uiAPtr->v0, sepChar ); + +} + +static bool writeGenOutputs_f128M( const float128_t *aPtr, uint_fast8_t flags ) +{ + + writeHex_uiF128M( aPtr, ' ' ); + writeGenOutput_flags( flags ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) return true; + } + return false; + +} + +#endif + +void gen_a_ui32( void ) +{ + + genCases_ui32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui32_a_next(); + writeHex_ui32( genCases_ui32_a, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_a_ui64( void ) +{ + + genCases_ui64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui64_a_next(); + writeHex_ui64( genCases_ui64_a, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_a_i32( void ) +{ + + genCases_i32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i32_a_next(); + writeHex_ui32( genCases_i32_a, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_a_i64( void ) +{ + + genCases_i64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i64_a_next(); + writeHex_ui64( genCases_i64_a, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +#ifdef FLOAT16 + +void gen_a_f16( void ) +{ + union ui16_f16 uA; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_ab_f16( void ) +{ + union ui16_f16 u; + + genCases_f16_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_ab_next(); + u.f = genCases_f16_a; + writeHex_ui16( u.ui, ' ' ); + u.f = genCases_f16_b; + writeHex_ui16( u.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_abc_f16( void ) +{ + union ui16_f16 u; + + genCases_f16_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_abc_next(); + u.f = genCases_f16_a; + writeHex_ui16( u.ui, ' ' ); + u.f = genCases_f16_b; + writeHex_ui16( u.ui, ' ' ); + u.f = genCases_f16_c; + writeHex_ui16( u.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +#endif + +void gen_a_f32( void ) +{ + union ui32_f32 uA; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_ab_f32( void ) +{ + union ui32_f32 u; + + genCases_f32_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_ab_next(); + u.f = genCases_f32_a; + writeHex_ui32( u.ui, ' ' ); + u.f = genCases_f32_b; + writeHex_ui32( u.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_abc_f32( void ) +{ + union ui32_f32 u; + + genCases_f32_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_abc_next(); + u.f = genCases_f32_a; + writeHex_ui32( u.ui, ' ' ); + u.f = genCases_f32_b; + writeHex_ui32( u.ui, ' ' ); + u.f = genCases_f32_c; + writeHex_ui32( u.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +#ifdef FLOAT64 + +void gen_a_f64( void ) +{ + union ui64_f64 uA; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_ab_f64( void ) +{ + union ui64_f64 u; + + genCases_f64_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_ab_next(); + u.f = genCases_f64_a; + writeHex_ui64( u.ui, ' ' ); + u.f = genCases_f64_b; + writeHex_ui64( u.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_abc_f64( void ) +{ + union ui64_f64 u; + + genCases_f64_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_abc_next(); + u.f = genCases_f64_a; + writeHex_ui64( u.ui, ' ' ); + u.f = genCases_f64_b; + writeHex_ui64( u.ui, ' ' ); + u.f = genCases_f64_c; + writeHex_ui64( u.ui, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void gen_a_extF80( void ) +{ + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_ab_extF80( void ) +{ + + genCases_extF80_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_ab_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + writeHex_uiExtF80M( &genCases_extF80_b, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_abc_extF80( void ) +{ + + genCases_extF80_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_abc_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + writeHex_uiExtF80M( &genCases_extF80_b, ' ' ); + writeHex_uiExtF80M( &genCases_extF80_c, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_f128( void ) +{ + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_ab_f128( void ) +{ + + genCases_f128_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_ab_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + writeHex_uiF128M( &genCases_f128_b, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +void gen_abc_f128( void ) +{ + + genCases_f128_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_abc_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + writeHex_uiF128M( &genCases_f128_b, ' ' ); + writeHex_uiF128M( &genCases_f128_c, '\n' ); + if ( genLoops_givenCount ) { + --genLoops_count; + if ( ! genLoops_count ) break; + } + } + +} + +#endif + +#ifdef FLOAT16 + +void gen_a_ui32_z_f16( float16_t trueFunction( uint32_t ) ) +{ + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_ui32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui32_a_next(); + writeHex_ui32( genCases_ui32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_ui32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +void gen_a_ui32_z_f32( float32_t trueFunction( uint32_t ) ) +{ + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_ui32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui32_a_next(); + writeHex_ui32( genCases_ui32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_ui32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void gen_a_ui32_z_f64( float64_t trueFunction( uint32_t ) ) +{ + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_ui32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui32_a_next(); + writeHex_ui32( genCases_ui32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_ui32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void gen_a_ui32_z_extF80( void trueFunction( uint32_t, extFloat80_t * ) ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_ui32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui32_a_next(); + writeHex_ui32( genCases_ui32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui32_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_ui32_z_f128( void trueFunction( uint32_t, float128_t * ) ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_ui32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui32_a_next(); + writeHex_ui32( genCases_ui32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui32_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT16 + +void gen_a_ui64_z_f16( float16_t trueFunction( uint64_t ) ) +{ + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_ui64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui64_a_next(); + writeHex_ui64( genCases_ui64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_ui64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +void gen_a_ui64_z_f32( float32_t trueFunction( uint64_t ) ) +{ + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_ui64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui64_a_next(); + writeHex_ui64( genCases_ui64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_ui64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void gen_a_ui64_z_f64( float64_t trueFunction( uint64_t ) ) +{ + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_ui64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui64_a_next(); + writeHex_ui64( genCases_ui64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_ui64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void gen_a_ui64_z_extF80( void trueFunction( uint64_t, extFloat80_t * ) ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_ui64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui64_a_next(); + writeHex_ui64( genCases_ui64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui64_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_ui64_z_f128( void trueFunction( uint64_t, float128_t * ) ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_ui64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_ui64_a_next(); + writeHex_ui64( genCases_ui64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui64_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT16 + +void gen_a_i32_z_f16( float16_t trueFunction( int32_t ) ) +{ + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_i32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i32_a_next(); + writeHex_ui32( genCases_i32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_i32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +void gen_a_i32_z_f32( float32_t trueFunction( int32_t ) ) +{ + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_i32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i32_a_next(); + writeHex_ui32( genCases_i32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_i32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void gen_a_i32_z_f64( float64_t trueFunction( int32_t ) ) +{ + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_i32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i32_a_next(); + writeHex_ui32( genCases_i32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_i32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void gen_a_i32_z_extF80( void trueFunction( int32_t, extFloat80_t * ) ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_i32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i32_a_next(); + writeHex_ui32( genCases_i32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_i32_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_i32_z_f128( void trueFunction( int32_t, float128_t * ) ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_i32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i32_a_next(); + writeHex_ui32( genCases_i32_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_i32_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT16 + +void gen_a_i64_z_f16( float16_t trueFunction( int64_t ) ) +{ + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_i64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i64_a_next(); + writeHex_ui64( genCases_i64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_i64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +void gen_a_i64_z_f32( float32_t trueFunction( int64_t ) ) +{ + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_i64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i64_a_next(); + writeHex_ui64( genCases_i64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_i64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void gen_a_i64_z_f64( float64_t trueFunction( int64_t ) ) +{ + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_i64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i64_a_next(); + writeHex_ui64( genCases_i64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_i64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void gen_a_i64_z_extF80( void trueFunction( int64_t, extFloat80_t * ) ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_i64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i64_a_next(); + writeHex_ui64( genCases_i64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_i64_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_i64_z_f128( void trueFunction( int64_t, float128_t * ) ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_i64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_i64_a_next(); + writeHex_ui64( genCases_i64_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_i64_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT16 + +void + gen_a_f16_z_ui32_rx( + uint_fast32_t trueFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui16_f16 uA; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f16_z_ui64_rx( + uint_fast64_t trueFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui16_f16 uA; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f16_z_i32_rx( + int_fast32_t trueFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui16_f16 uA; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f16_z_i64_rx( + int_fast64_t trueFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui16_f16 uA; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f16_z_ui32_x( + uint_fast32_t trueFunction( float16_t, bool ), bool exact ) +{ + union ui16_f16 uA; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f16_z_ui64_x( + uint_fast64_t trueFunction( float16_t, bool ), bool exact ) +{ + union ui16_f16 uA; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f16_z_i32_x( int_fast32_t trueFunction( float16_t, bool ), bool exact ) +{ + union ui16_f16 uA; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f16_z_i64_x( int_fast64_t trueFunction( float16_t, bool ), bool exact ) +{ + union ui16_f16 uA; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void gen_a_f16_z_f32( float32_t trueFunction( float16_t ) ) +{ + union ui16_f16 uA; + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_f16_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void gen_a_f16_z_f64( float64_t trueFunction( float16_t ) ) +{ + union ui16_f16 uA; + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_f16_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void gen_a_f16_z_extF80( void trueFunction( float16_t, extFloat80_t * ) ) +{ + union ui16_f16 uA; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_f16_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_f16_z_f128( void trueFunction( float16_t, float128_t * ) ) +{ + union ui16_f16 uA; + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + uA.f = genCases_f16_a; + writeHex_ui16( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_f16_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +void gen_az_f16( float16_t trueFunction( float16_t ) ) +{ + union ui16_f16 u; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + u.f = genCases_f16_a; + writeHex_ui16( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f16_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break; + } + +} + +void + gen_az_f16_rx( + float16_t trueFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui16_f16 u; + uint_fast8_t trueFlags; + + genCases_f16_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_a_next(); + u.f = genCases_f16_a; + writeHex_ui16( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break; + } + +} + +void gen_abz_f16( float16_t trueFunction( float16_t, float16_t ) ) +{ + union ui16_f16 u; + uint_fast8_t trueFlags; + + genCases_f16_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_ab_next(); + u.f = genCases_f16_a; + writeHex_ui16( u.ui, ' ' ); + u.f = genCases_f16_b; + writeHex_ui16( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f16_a, genCases_f16_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break; + } + +} + +void gen_abcz_f16( float16_t trueFunction( float16_t, float16_t, float16_t ) ) +{ + union ui16_f16 u; + uint_fast8_t trueFlags; + + genCases_f16_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_abc_next(); + u.f = genCases_f16_a; + writeHex_ui16( u.ui, ' ' ); + u.f = genCases_f16_b; + writeHex_ui16( u.ui, ' ' ); + u.f = genCases_f16_c; + writeHex_ui16( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f16_a, genCases_f16_b, genCases_f16_c ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( u.ui, trueFlags ) ) break; + } + +} + +void gen_ab_f16_z_bool( bool trueFunction( float16_t, float16_t ) ) +{ + union ui16_f16 u; + bool trueZ; + uint_fast8_t trueFlags; + + genCases_f16_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f16_ab_next(); + u.f = genCases_f16_a; + writeHex_ui16( u.ui, ' ' ); + u.f = genCases_f16_b; + writeHex_ui16( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, genCases_f16_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_bool( trueZ, trueFlags ) ) break; + } + +} + +#endif + +void + gen_a_f32_z_ui32_rx( + uint_fast32_t trueFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui32_f32 uA; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f32_z_ui64_rx( + uint_fast64_t trueFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui32_f32 uA; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f32_z_i32_rx( + int_fast32_t trueFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui32_f32 uA; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f32_z_i64_rx( + int_fast64_t trueFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui32_f32 uA; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f32_z_ui32_x( + uint_fast32_t trueFunction( float32_t, bool ), bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f32_z_ui64_x( + uint_fast64_t trueFunction( float32_t, bool ), bool exact ) +{ + union ui32_f32 uA; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f32_z_i32_x( int_fast32_t trueFunction( float32_t, bool ), bool exact ) +{ + union ui32_f32 uA; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f32_z_i64_x( int_fast64_t trueFunction( float32_t, bool ), bool exact ) +{ + union ui32_f32 uA; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +#ifdef FLOAT16 + +void gen_a_f32_z_f16( float16_t trueFunction( float32_t ) ) +{ + union ui32_f32 uA; + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_f32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT64 + +void gen_a_f32_z_f64( float64_t trueFunction( float32_t ) ) +{ + union ui32_f32 uA; + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_f32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void gen_a_f32_z_extF80( void trueFunction( float32_t, extFloat80_t * ) ) +{ + union ui32_f32 uA; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_f32_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_f32_z_f128( void trueFunction( float32_t, float128_t * ) ) +{ + union ui32_f32 uA; + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + uA.f = genCases_f32_a; + writeHex_ui32( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_f32_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +void gen_az_f32( float32_t trueFunction( float32_t ) ) +{ + union ui32_f32 u; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + u.f = genCases_f32_a; + writeHex_ui32( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f32_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( u.ui, trueFlags ) ) break; + } + +} + +void + gen_az_f32_rx( + float32_t trueFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui32_f32 u; + uint_fast8_t trueFlags; + + genCases_f32_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_a_next(); + u.f = genCases_f32_a; + writeHex_ui32( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( u.ui, trueFlags ) ) break; + } + +} + +void gen_abz_f32( float32_t trueFunction( float32_t, float32_t ) ) +{ + union ui32_f32 u; + uint_fast8_t trueFlags; + + genCases_f32_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_ab_next(); + u.f = genCases_f32_a; + writeHex_ui32( u.ui, ' ' ); + u.f = genCases_f32_b; + writeHex_ui32( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f32_a, genCases_f32_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( u.ui, trueFlags ) ) break; + } + +} + +void gen_abcz_f32( float32_t trueFunction( float32_t, float32_t, float32_t ) ) +{ + union ui32_f32 u; + uint_fast8_t trueFlags; + + genCases_f32_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_abc_next(); + u.f = genCases_f32_a; + writeHex_ui32( u.ui, ' ' ); + u.f = genCases_f32_b; + writeHex_ui32( u.ui, ' ' ); + u.f = genCases_f32_c; + writeHex_ui32( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f32_a, genCases_f32_b, genCases_f32_c ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( u.ui, trueFlags ) ) break; + } + +} + +void gen_ab_f32_z_bool( bool trueFunction( float32_t, float32_t ) ) +{ + union ui32_f32 u; + bool trueZ; + uint_fast8_t trueFlags; + + genCases_f32_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f32_ab_next(); + u.f = genCases_f32_a; + writeHex_ui32( u.ui, ' ' ); + u.f = genCases_f32_b; + writeHex_ui32( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, genCases_f32_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_bool( trueZ, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void + gen_a_f64_z_ui32_rx( + uint_fast32_t trueFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui64_f64 uA; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f64_z_ui64_rx( + uint_fast64_t trueFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui64_f64 uA; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f64_z_i32_rx( + int_fast32_t trueFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui64_f64 uA; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f64_z_i64_rx( + int_fast64_t trueFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui64_f64 uA; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f64_z_ui32_x( + uint_fast32_t trueFunction( float64_t, bool ), bool exact ) +{ + union ui64_f64 uA; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f64_z_ui64_x( + uint_fast64_t trueFunction( float64_t, bool ), bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f64_z_i32_x( int_fast32_t trueFunction( float64_t, bool ), bool exact ) +{ + union ui64_f64 uA; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f64_z_i64_x( int_fast64_t trueFunction( float64_t, bool ), bool exact ) +{ + union ui64_f64 uA; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +#ifdef FLOAT16 + +void gen_a_f64_z_f16( float16_t trueFunction( float64_t ) ) +{ + union ui64_f64 uA; + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_f64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +void gen_a_f64_z_f32( float32_t trueFunction( float64_t ) ) +{ + union ui64_f64 uA; + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( genCases_f64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef EXTFLOAT80 + +void gen_a_f64_z_extF80( void trueFunction( float64_t, extFloat80_t * ) ) +{ + union ui64_f64 uA; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_f64_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void gen_a_f64_z_f128( void trueFunction( float64_t, float128_t * ) ) +{ + union ui64_f64 uA; + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + uA.f = genCases_f64_a; + writeHex_ui64( uA.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( genCases_f64_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +void gen_az_f64( float64_t trueFunction( float64_t ) ) +{ + union ui64_f64 u; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + u.f = genCases_f64_a; + writeHex_ui64( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f64_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( u.ui, trueFlags ) ) break; + } + +} + +void + gen_az_f64_rx( + float64_t trueFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + union ui64_f64 u; + uint_fast8_t trueFlags; + + genCases_f64_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_a_next(); + u.f = genCases_f64_a; + writeHex_ui64( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( u.ui, trueFlags ) ) break; + } + +} + +void gen_abz_f64( float64_t trueFunction( float64_t, float64_t ) ) +{ + union ui64_f64 u; + uint_fast8_t trueFlags; + + genCases_f64_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_ab_next(); + u.f = genCases_f64_a; + writeHex_ui64( u.ui, ' ' ); + u.f = genCases_f64_b; + writeHex_ui64( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f64_a, genCases_f64_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( u.ui, trueFlags ) ) break; + } + +} + +void gen_abcz_f64( float64_t trueFunction( float64_t, float64_t, float64_t ) ) +{ + union ui64_f64 u; + uint_fast8_t trueFlags; + + genCases_f64_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_abc_next(); + u.f = genCases_f64_a; + writeHex_ui64( u.ui, ' ' ); + u.f = genCases_f64_b; + writeHex_ui64( u.ui, ' ' ); + u.f = genCases_f64_c; + writeHex_ui64( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + u.f = trueFunction( genCases_f64_a, genCases_f64_b, genCases_f64_c ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( u.ui, trueFlags ) ) break; + } + +} + +void gen_ab_f64_z_bool( bool trueFunction( float64_t, float64_t ) ) +{ + union ui64_f64 u; + bool trueZ; + uint_fast8_t trueFlags; + + genCases_f64_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f64_ab_next(); + u.f = genCases_f64_a; + writeHex_ui64( u.ui, ' ' ); + u.f = genCases_f64_b; + writeHex_ui64( u.ui, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, genCases_f64_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_bool( trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void + gen_a_extF80_z_ui32_rx( + uint_fast32_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_extF80_z_ui64_rx( + uint_fast64_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_extF80_z_i32_rx( + int_fast32_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_extF80_z_i64_rx( + int_fast64_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_extF80_z_ui32_x( + uint_fast32_t trueFunction( const extFloat80_t *, bool ), bool exact ) +{ + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_extF80_z_ui64_x( + uint_fast64_t trueFunction( const extFloat80_t *, bool ), bool exact ) +{ + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_extF80_z_i32_x( + int_fast32_t trueFunction( const extFloat80_t *, bool ), bool exact ) +{ + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_extF80_z_i64_x( + int_fast64_t trueFunction( const extFloat80_t *, bool ), bool exact ) +{ + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +#ifdef FLOAT16 + +void gen_a_extF80_z_f16( float16_t trueFunction( const extFloat80_t * ) ) +{ + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( &genCases_extF80_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +void gen_a_extF80_z_f32( float32_t trueFunction( const extFloat80_t * ) ) +{ + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( &genCases_extF80_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void gen_a_extF80_z_f64( float64_t trueFunction( const extFloat80_t * ) ) +{ + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( &genCases_extF80_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void + gen_a_extF80_z_f128( void trueFunction( const extFloat80_t *, float128_t * ) ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +void gen_az_extF80( void trueFunction( const extFloat80_t *, extFloat80_t * ) ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +void + gen_az_extF80_rx( + void + trueFunction( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ), + uint_fast8_t roundingMode, + bool exact + ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_a_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, roundingMode, exact, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +void + gen_abz_extF80( + void + trueFunction( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ) + ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_ab_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + writeHex_uiExtF80M( &genCases_extF80_b, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, &genCases_extF80_b, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +void + gen_ab_extF80_z_bool( + bool trueFunction( const extFloat80_t *, const extFloat80_t * ) ) +{ + bool trueZ; + uint_fast8_t trueFlags; + + genCases_extF80_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_extF80_ab_next(); + writeHex_uiExtF80M( &genCases_extF80_a, ' ' ); + writeHex_uiExtF80M( &genCases_extF80_b, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, &genCases_extF80_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_bool( trueZ, trueFlags ) ) break; + } + +} + +#endif + +#ifdef FLOAT128 + +void + gen_a_f128_z_ui32_rx( + uint_fast32_t trueFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f128_z_ui64_rx( + uint_fast64_t trueFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f128_z_i32_rx( + int_fast32_t trueFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f128_z_i64_rx( + int_fast64_t trueFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f128_z_ui32_x( + uint_fast32_t trueFunction( const float128_t *, bool ), bool exact ) +{ + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f128_z_ui64_x( + uint_fast64_t trueFunction( const float128_t *, bool ), bool exact ) +{ + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f128_z_i32_x( + int_fast32_t trueFunction( const float128_t *, bool ), bool exact ) +{ + int_fast32_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( trueZ, trueFlags ) ) break; + } + +} + +void + gen_a_f128_z_i64_x( + int_fast64_t trueFunction( const float128_t *, bool ), bool exact ) +{ + int_fast64_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( trueZ, trueFlags ) ) break; + } + +} + +#ifdef FLOAT16 + +void gen_a_f128_z_f16( float16_t trueFunction( const float128_t * ) ) +{ + union ui16_f16 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( &genCases_f128_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui16( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +void gen_a_f128_z_f32( float32_t trueFunction( const float128_t * ) ) +{ + union ui32_f32 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( &genCases_f128_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui32( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#ifdef FLOAT64 + +void gen_a_f128_z_f64( float64_t trueFunction( const float128_t * ) ) +{ + union ui64_f64 uTrueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + uTrueZ.f = trueFunction( &genCases_f128_a ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_ui64( uTrueZ.ui, trueFlags ) ) break; + } + +} + +#endif + +#ifdef EXTFLOAT80 + +void + gen_a_f128_z_extF80( void trueFunction( const float128_t *, extFloat80_t * ) ) +{ + extFloat80_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_extF80M( &trueZ, trueFlags ) ) break; + } + +} + +#endif + +void gen_az_f128( void trueFunction( const float128_t *, float128_t * ) ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +void + gen_az_f128_rx( + void trueFunction( const float128_t *, uint_fast8_t, bool, float128_t * ), + uint_fast8_t roundingMode, + bool exact + ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_a_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_a_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, roundingMode, exact, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +void + gen_abz_f128( + void trueFunction( const float128_t *, const float128_t *, float128_t * ) + ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_ab_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + writeHex_uiF128M( &genCases_f128_b, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, &genCases_f128_b, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +void + gen_abcz_f128( + void + trueFunction( + const float128_t *, + const float128_t *, + const float128_t *, + float128_t * + ) + ) +{ + float128_t trueZ; + uint_fast8_t trueFlags; + + genCases_f128_abc_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_abc_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + writeHex_uiF128M( &genCases_f128_b, ' ' ); + writeHex_uiF128M( &genCases_f128_c, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueFunction( + &genCases_f128_a, &genCases_f128_b, &genCases_f128_c, &trueZ ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_f128M( &trueZ, trueFlags ) ) break; + } + +} + +void + gen_ab_f128_z_bool( + bool trueFunction( const float128_t *, const float128_t * ) ) +{ + bool trueZ; + uint_fast8_t trueFlags; + + genCases_f128_ab_init(); + checkEnoughCases(); + while ( ! genLoops_stop && (! genCases_done || genLoops_forever) ) { + genCases_f128_ab_next(); + writeHex_uiF128M( &genCases_f128_a, ' ' ); + writeHex_uiF128M( &genCases_f128_b, ' ' ); + *genLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, &genCases_f128_b ); + trueFlags = *genLoops_trueFlagsPtr; + if ( writeGenOutputs_bool( trueZ, trueFlags ) ) break; + } + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.h new file mode 100644 index 000000000..f574b7757 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/genLoops.h @@ -0,0 +1,354 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include +#include "softfloat.h" + +extern volatile sig_atomic_t genLoops_stop; + +extern bool genLoops_forever; +extern bool genLoops_givenCount; +extern uint_fast64_t genLoops_count; +extern uint_fast8_t *genLoops_trueFlagsPtr; + +void gen_a_ui32( void ); +void gen_a_ui64( void ); +void gen_a_i32( void ); +void gen_a_i64( void ); +#ifdef FLOAT16 +void gen_a_f16( void ); +void gen_ab_f16( void ); +void gen_abc_f16( void ); +#endif +void gen_a_f32( void ); +void gen_ab_f32( void ); +void gen_abc_f32( void ); +#ifdef FLOAT64 +void gen_a_f64( void ); +void gen_ab_f64( void ); +void gen_abc_f64( void ); +#endif +#ifdef EXTFLOAT80 +void gen_a_extF80( void ); +void gen_ab_extF80( void ); +void gen_abc_extF80( void ); +#endif +#ifdef FLOAT128 +void gen_a_f128( void ); +void gen_ab_f128( void ); +void gen_abc_f128( void ); +#endif + +#ifdef FLOAT16 +void gen_a_ui32_z_f16( float16_t ( uint32_t ) ); +#endif +void gen_a_ui32_z_f32( float32_t ( uint32_t ) ); +#ifdef FLOAT64 +void gen_a_ui32_z_f64( float64_t ( uint32_t ) ); +#endif +#ifdef EXTFLOAT80 +void gen_a_ui32_z_extF80( void ( uint32_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_ui32_z_f128( void ( uint32_t, float128_t * ) ); +#endif +#ifdef FLOAT16 +void gen_a_ui64_z_f16( float16_t ( uint64_t ) ); +#endif +void gen_a_ui64_z_f32( float32_t ( uint64_t ) ); +#ifdef FLOAT64 +void gen_a_ui64_z_f64( float64_t ( uint64_t ) ); +#endif +#ifdef EXTFLOAT80 +void gen_a_ui64_z_extF80( void ( uint64_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_ui64_z_f128( void ( uint64_t, float128_t * ) ); +#endif +#ifdef FLOAT16 +void gen_a_i32_z_f16( float16_t ( int32_t ) ); +#endif +void gen_a_i32_z_f32( float32_t ( int32_t ) ); +#ifdef FLOAT64 +void gen_a_i32_z_f64( float64_t ( int32_t ) ); +#endif +#ifdef EXTFLOAT80 +void gen_a_i32_z_extF80( void ( int32_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_i32_z_f128( void ( int32_t, float128_t * ) ); +#endif +#ifdef FLOAT16 +void gen_a_i64_z_f16( float16_t ( int64_t ) ); +#endif +void gen_a_i64_z_f32( float32_t ( int64_t ) ); +#ifdef FLOAT64 +void gen_a_i64_z_f64( float64_t ( int64_t ) ); +#endif +#ifdef EXTFLOAT80 +void gen_a_i64_z_extF80( void ( int64_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_i64_z_f128( void ( int64_t, float128_t * ) ); +#endif + +#ifdef FLOAT16 +void + gen_a_f16_z_ui32_rx( + uint_fast32_t ( float16_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f16_z_ui64_rx( + uint_fast64_t ( float16_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f16_z_i32_rx( + int_fast32_t ( float16_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f16_z_i64_rx( + int_fast64_t ( float16_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void gen_a_f16_z_ui32_x( uint_fast32_t ( float16_t, bool ), bool ); +void gen_a_f16_z_ui64_x( uint_fast64_t ( float16_t, bool ), bool ); +void gen_a_f16_z_i32_x( int_fast32_t ( float16_t, bool ), bool ); +void gen_a_f16_z_i64_x( int_fast64_t ( float16_t, bool ), bool ); +void gen_a_f16_z_f32( float32_t ( float16_t ) ); +#ifdef FLOAT64 +void gen_a_f16_z_f64( float64_t ( float16_t ) ); +#endif +#ifdef EXTFLOAT80 +void gen_a_f16_z_extF80( void ( float16_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_f16_z_f128( void ( float16_t, float128_t * ) ); +#endif +void gen_az_f16( float16_t ( float16_t ) ); +void + gen_az_f16_rx( + float16_t ( float16_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void gen_abz_f16( float16_t ( float16_t, float16_t ) ); +void gen_abcz_f16( float16_t ( float16_t, float16_t, float16_t ) ); +void gen_ab_f16_z_bool( bool ( float16_t, float16_t ) ); +#endif + +void + gen_a_f32_z_ui32_rx( + uint_fast32_t ( float32_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f32_z_ui64_rx( + uint_fast64_t ( float32_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f32_z_i32_rx( + int_fast32_t ( float32_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f32_z_i64_rx( + int_fast64_t ( float32_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void gen_a_f32_z_ui32_x( uint_fast32_t ( float32_t, bool ), bool ); +void gen_a_f32_z_ui64_x( uint_fast64_t ( float32_t, bool ), bool ); +void gen_a_f32_z_i32_x( int_fast32_t ( float32_t, bool ), bool ); +void gen_a_f32_z_i64_x( int_fast64_t ( float32_t, bool ), bool ); +#ifdef FLOAT16 +void gen_a_f32_z_f16( float16_t ( float32_t ) ); +#endif +#ifdef FLOAT64 +void gen_a_f32_z_f64( float64_t ( float32_t ) ); +#endif +#ifdef EXTFLOAT80 +void gen_a_f32_z_extF80( void ( float32_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_f32_z_f128( void ( float32_t, float128_t * ) ); +#endif +void gen_az_f32( float32_t ( float32_t ) ); +void + gen_az_f32_rx( + float32_t ( float32_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void gen_abz_f32( float32_t ( float32_t, float32_t ) ); +void gen_abcz_f32( float32_t ( float32_t, float32_t, float32_t ) ); +void gen_ab_f32_z_bool( bool ( float32_t, float32_t ) ); + +#ifdef FLOAT64 +void + gen_a_f64_z_ui32_rx( + uint_fast32_t ( float64_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f64_z_ui64_rx( + uint_fast64_t ( float64_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f64_z_i32_rx( + int_fast32_t ( float64_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void + gen_a_f64_z_i64_rx( + int_fast64_t ( float64_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void gen_a_f64_z_ui32_x( uint_fast32_t ( float64_t, bool ), bool ); +void gen_a_f64_z_ui64_x( uint_fast64_t ( float64_t, bool ), bool ); +void gen_a_f64_z_i32_x( int_fast32_t ( float64_t, bool ), bool ); +void gen_a_f64_z_i64_x( int_fast64_t ( float64_t, bool ), bool ); +#ifdef FLOAT16 +void gen_a_f64_z_f16( float16_t ( float64_t ) ); +#endif +void gen_a_f64_z_f32( float32_t ( float64_t ) ); +#ifdef EXTFLOAT80 +void gen_a_f64_z_extF80( void ( float64_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_f64_z_f128( void ( float64_t, float128_t * ) ); +#endif +void gen_az_f64( float64_t ( float64_t ) ); +void + gen_az_f64_rx( + float64_t ( float64_t, uint_fast8_t, bool ), uint_fast8_t, bool ); +void gen_abz_f64( float64_t ( float64_t, float64_t ) ); +void gen_abcz_f64( float64_t ( float64_t, float64_t, float64_t ) ); +void gen_ab_f64_z_bool( bool ( float64_t, float64_t ) ); +#endif + +#ifdef EXTFLOAT80 +void + gen_a_extF80_z_ui32_rx( + uint_fast32_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + gen_a_extF80_z_ui64_rx( + uint_fast64_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + gen_a_extF80_z_i32_rx( + int_fast32_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + gen_a_extF80_z_i64_rx( + int_fast64_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + gen_a_extF80_z_ui32_x( uint_fast32_t ( const extFloat80_t *, bool ), bool ); +void + gen_a_extF80_z_ui64_x( uint_fast64_t ( const extFloat80_t *, bool ), bool ); +void gen_a_extF80_z_i32_x( int_fast32_t ( const extFloat80_t *, bool ), bool ); +void gen_a_extF80_z_i64_x( int_fast64_t ( const extFloat80_t *, bool ), bool ); +#ifdef FLOAT16 +void gen_a_extF80_z_f16( float16_t ( const extFloat80_t * ) ); +#endif +void gen_a_extF80_z_f32( float32_t ( const extFloat80_t * ) ); +#ifdef FLOAT64 +void gen_a_extF80_z_f64( float64_t ( const extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void gen_a_extF80_z_f128( void ( const extFloat80_t *, float128_t * ) ); +#endif +void gen_az_extF80( void ( const extFloat80_t *, extFloat80_t * ) ); +void + gen_az_extF80_rx( + void ( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ), + uint_fast8_t, + bool + ); +void + gen_abz_extF80( + void ( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ) ); +void + gen_ab_extF80_z_bool( bool ( const extFloat80_t *, const extFloat80_t * ) ); +#endif + +#ifdef FLOAT128 +void + gen_a_f128_z_ui32_rx( + uint_fast32_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + gen_a_f128_z_ui64_rx( + uint_fast64_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + gen_a_f128_z_i32_rx( + int_fast32_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + gen_a_f128_z_i64_rx( + int_fast64_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void gen_a_f128_z_ui32_x( uint_fast32_t ( const float128_t *, bool ), bool ); +void gen_a_f128_z_ui64_x( uint_fast64_t ( const float128_t *, bool ), bool ); +void gen_a_f128_z_i32_x( int_fast32_t ( const float128_t *, bool ), bool ); +void gen_a_f128_z_i64_x( int_fast64_t ( const float128_t *, bool ), bool ); +#ifdef FLOAT16 +void gen_a_f128_z_f16( float16_t ( const float128_t * ) ); +#endif +void gen_a_f128_z_f32( float32_t ( const float128_t * ) ); +#ifdef FLOAT64 +void gen_a_f128_z_f64( float64_t ( const float128_t * ) ); +#endif +#ifdef EXTFLOAT80 +void gen_a_f128_z_extF80( void ( const float128_t *, extFloat80_t * ) ); +#endif +void gen_az_f128( void ( const float128_t *, float128_t * ) ); +void + gen_az_f128_rx( + void ( const float128_t *, uint_fast8_t, bool, float128_t * ), + uint_fast8_t, + bool + ); +void + gen_abz_f128( void ( const float128_t *, const float128_t *, float128_t * ) ); +void + gen_abcz_f128( + void + ( + const float128_t *, + const float128_t *, + const float128_t *, + float128_t * + ) + ); +void gen_ab_f128_z_bool( bool ( const float128_t *, const float128_t * ) ); +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/random.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/random.c new file mode 100644 index 000000000..da0613db2 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/random.c @@ -0,0 +1,138 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "random.h" + +uint_fast8_t random_ui8( void ) +{ + + return rand()>>4 & 0xFF; + +} + +uint_fast16_t random_ui16( void ) +{ + + return (rand() & 0x0FF0)<<4 | (rand()>>4 & 0xFF); + +} + +uint_fast32_t random_ui32( void ) +{ + + return + (uint_fast32_t) (rand() & 0x0FF0)<<20 + | (uint_fast32_t) (rand() & 0x0FF0)<<12 + | (rand() & 0x0FF0)<<4 + | (rand()>>4 & 0xFF); + +} + +uint_fast64_t random_ui64( void ) +{ + + return (uint_fast64_t) random_ui32()<<32 | random_ui32(); + +} + +uint_fast8_t randomN_ui8( uint_fast8_t N ) +{ + uint_fast8_t scale, z; + + scale = 0; + while ( N < 0x80 ) { + ++scale; + N <<= 1; + } + do { + z = random_ui8(); + } while ( N <= z ); + return z>>scale; + +} + +uint_fast16_t randomN_ui16( uint_fast16_t N ) +{ + uint_fast16_t scale, z; + + scale = 0; + while ( N < 0x8000 ) { + ++scale; + N <<= 1; + } + do { + z = random_ui16(); + } while ( N <= z ); + return z>>scale; + +} + +uint_fast32_t randomN_ui32( uint_fast32_t N ) +{ + uint_fast32_t scale, z; + + scale = 0; + while ( N < 0x8000 ) { + ++scale; + N <<= 1; + } + do { + z = random_ui32(); + } while ( N <= z ); + return z>>scale; + +} + +uint_fast64_t randomN_ui64( uint_fast64_t N ) +{ + uint_fast64_t scale, z; + + scale = 0; + while ( N < 0x8000 ) { + ++scale; + N <<= 1; + } + do { + z = random_ui64(); + } while ( N <= z ); + return z>>scale; + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/random.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/random.h new file mode 100644 index 000000000..92fe77975 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/random.h @@ -0,0 +1,49 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include + +uint_fast8_t random_ui8( void ); +uint_fast16_t random_ui16( void ); +uint_fast32_t random_ui32( void ); +uint_fast64_t random_ui64( void ); + +uint_fast8_t randomN_ui8( uint_fast8_t ); +uint_fast16_t randomN_ui16( uint_fast16_t ); +uint_fast32_t randomN_ui32( uint_fast32_t ); +uint_fast64_t randomN_ui64( uint_fast64_t ); + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.c new file mode 100644 index 000000000..31182b85c --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.c @@ -0,0 +1,190 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include +#include "platform.h" +#include "readHex.h" + +bool readHex_bool( bool *aPtr, char sepChar ) +{ + int i; + bool a; + + i = fgetc( stdin ); + if ( (i == EOF) || (i < '0') || ('1' < i) ) return false; + a = i - '0'; + if ( sepChar ) { + i = fgetc( stdin ); + if ( (sepChar != '\n') || (i != '\r') ) { + if ( i != sepChar ) return false; + } + } + *aPtr = a; + return true; + +} + +bool readHex_ui8( uint_least8_t *aPtr, char sepChar ) +{ + int i; + uint_fast8_t a; + + i = fgetc( stdin ); + if ( i == EOF ) return false; + if ( ('0' <= i) && (i <= '9') ) { + i -= '0'; + } else if ( ('A' <= i) && (i <= 'F') ) { + i -= 'A' - 10; + } else if ( ('a' <= i) && (i <= 'f') ) { + i -= 'a' - 10; + } else { + return false; + } + a = i<<4; + i = fgetc( stdin ); + if ( i == EOF ) return false; + if ( ('0' <= i) && (i <= '9') ) { + i -= '0'; + } else if ( ('A' <= i) && (i <= 'F') ) { + i -= 'A' - 10; + } else if ( ('a' <= i) && (i <= 'f') ) { + i -= 'a' - 10; + } else { + return false; + } + a |= i; + if ( sepChar ) { + i = fgetc( stdin ); + if ( (sepChar != '\n') || (i != '\r') ) { + if ( i != sepChar ) return false; + } + } + *aPtr = a; + return true; + +} + +bool readHex_ui16( uint16_t *aPtr, char sepChar ) +{ + int i; + uint_fast16_t a; + + i = fgetc( stdin ); + if ( i == EOF ) return false; + if ( ('0' <= i) && (i <= '9') ) { + i -= '0'; + } else if ( ('A' <= i) && (i <= 'F') ) { + i -= 'A' - 10; + } else if ( ('a' <= i) && (i <= 'f') ) { + i -= 'a' - 10; + } else { + return false; + } + a = (uint_fast16_t) i<<12; + i = fgetc( stdin ); + if ( i == EOF ) return false; + if ( ('0' <= i) && (i <= '9') ) { + i -= '0'; + } else if ( ('A' <= i) && (i <= 'F') ) { + i -= 'A' - 10; + } else if ( ('a' <= i) && (i <= 'f') ) { + i -= 'a' - 10; + } else { + return false; + } + a |= (uint_fast16_t) i<<8; + i = fgetc( stdin ); + if ( i == EOF ) return false; + if ( ('0' <= i) && (i <= '9') ) { + i -= '0'; + } else if ( ('A' <= i) && (i <= 'F') ) { + i -= 'A' - 10; + } else if ( ('a' <= i) && (i <= 'f') ) { + i -= 'a' - 10; + } else { + return false; + } + a |= (uint_fast16_t) i<<4; + i = fgetc( stdin ); + if ( i == EOF ) return false; + if ( ('0' <= i) && (i <= '9') ) { + i -= '0'; + } else if ( ('A' <= i) && (i <= 'F') ) { + i -= 'A' - 10; + } else if ( ('a' <= i) && (i <= 'f') ) { + i -= 'a' - 10; + } else { + return false; + } + a |= i; + if ( sepChar ) { + i = fgetc( stdin ); + if ( (sepChar != '\n') || (i != '\r') ) { + if ( i != sepChar ) return false; + } + } + *aPtr = a; + return true; + +} + +bool readHex_ui32( uint32_t *aPtr, char sepChar ) +{ + uint16_t v16, v0; + + if ( ! readHex_ui16( &v16, 0 ) || ! readHex_ui16( &v0, sepChar ) ) { + return false; + } + *aPtr = (uint_fast32_t) v16<<16 | v0; + return true; + +} + +bool readHex_ui64( uint64_t *aPtr, char sepChar ) +{ + uint32_t v32, v0; + + if ( ! readHex_ui32( &v32, 0 ) || ! readHex_ui32( &v0, sepChar ) ) { + return false; + } + *aPtr = (uint_fast64_t) v32<<32 | v0; + return true; + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.h new file mode 100644 index 000000000..82662571c --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/readHex.h @@ -0,0 +1,46 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include + +bool readHex_bool( bool *, char ); +bool readHex_ui8( uint_least8_t *, char ); +bool readHex_ui16( uint16_t *, char ); +bool readHex_ui32( uint32_t *, char ); +bool readHex_ui64( uint64_t *, char ); + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.c new file mode 100644 index 000000000..d5252613d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.c @@ -0,0 +1,3749 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "uint128.h" +#include "softfloat.h" +#include "slowfloat.h" + +uint_fast8_t slowfloat_roundingMode; +uint_fast8_t slowfloat_detectTininess; +uint_fast8_t slowfloat_exceptionFlags; +#ifdef EXTFLOAT80 +uint_fast8_t slow_extF80_roundingPrecision; +#endif + +#ifdef FLOAT16 +union ui16_f16 { uint16_t ui; float16_t f; }; +#endif +union ui32_f32 { uint32_t ui; float32_t f; }; +#ifdef FLOAT64 +union ui64_f64 { uint64_t ui; float64_t f; }; +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +struct floatX { + bool isNaN; + bool isInf; + bool isZero; + bool sign; + int_fast32_t exp; + struct uint128 sig; +}; + +static const struct floatX floatXNaN = + { true, false, false, false, 0, { 0, 0 } }; +static const struct floatX floatXPositiveZero = + { false, false, true, false, 0, { 0, 0 } }; +static const struct floatX floatXNegativeZero = + { false, false, true, true, 0, { 0, 0 } }; + +static +void + roundFloatXTo11( + bool isTiny, struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast64_t roundBits, sigX64; + + sigX64 = xPtr->sig.v64; + roundBits = (sigX64 & UINT64_C( 0x1FFFFFFFFFFF )) | (xPtr->sig.v0 != 0); + if ( roundBits ) { + sigX64 &= UINT64_C( 0xFFFFE00000000000 ); + if ( exact ) slowfloat_exceptionFlags |= softfloat_flag_inexact; + if ( isTiny ) slowfloat_exceptionFlags |= softfloat_flag_underflow; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( roundBits < UINT64_C( 0x100000000000 ) ) goto noIncrement; + if ( + (roundBits == UINT64_C( 0x100000000000 )) + && !(sigX64 & UINT64_C( 0x200000000000 )) + ) { + goto noIncrement; + } + break; + case softfloat_round_minMag: + goto noIncrement; + case softfloat_round_min: + if ( !xPtr->sign ) goto noIncrement; + break; + case softfloat_round_max: + if ( xPtr->sign ) goto noIncrement; + break; + case softfloat_round_near_maxMag: + if ( roundBits < UINT64_C( 0x100000000000 ) ) goto noIncrement; + break; +#ifdef FLOAT_ROUND_ODD + case softfloat_round_odd: + sigX64 |= UINT64_C( 0x200000000000 ); + goto noIncrement; +#endif + } + sigX64 += UINT64_C( 0x200000000000 ); + if ( sigX64 == UINT64_C( 0x0100000000000000 ) ) { + ++xPtr->exp; + sigX64 = UINT64_C( 0x0080000000000000 ); + } + noIncrement: + xPtr->sig.v64 = sigX64; + xPtr->sig.v0 = 0; + } + +} + +static +void + roundFloatXTo24( + bool isTiny, struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast64_t sigX64; + uint_fast32_t roundBits; + + sigX64 = xPtr->sig.v64; + roundBits = (uint32_t) sigX64 | (xPtr->sig.v0 != 0); + if ( roundBits ) { + sigX64 &= UINT64_C( 0xFFFFFFFF00000000 ); + if ( exact ) slowfloat_exceptionFlags |= softfloat_flag_inexact; + if ( isTiny ) slowfloat_exceptionFlags |= softfloat_flag_underflow; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( roundBits < 0x80000000 ) goto noIncrement; + if ( + (roundBits == 0x80000000) + && !(sigX64 & UINT64_C( 0x100000000 )) + ) { + goto noIncrement; + } + break; + case softfloat_round_minMag: + goto noIncrement; + case softfloat_round_min: + if ( !xPtr->sign ) goto noIncrement; + break; + case softfloat_round_max: + if ( xPtr->sign ) goto noIncrement; + break; + case softfloat_round_near_maxMag: + if ( roundBits < 0x80000000 ) goto noIncrement; + break; +#ifdef FLOAT_ROUND_ODD + case softfloat_round_odd: + sigX64 |= UINT64_C( 0x100000000 ); + goto noIncrement; +#endif + } + sigX64 += UINT64_C( 0x100000000 ); + if ( sigX64 == UINT64_C( 0x0100000000000000 ) ) { + ++xPtr->exp; + sigX64 = UINT64_C( 0x0080000000000000 ); + } + noIncrement: + xPtr->sig.v64 = sigX64; + xPtr->sig.v0 = 0; + } + +} + +static +void + roundFloatXTo53( + bool isTiny, struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast64_t sigX64; + uint_fast8_t roundBits; + + sigX64 = xPtr->sig.v64; + roundBits = (sigX64 & 7) | (xPtr->sig.v0 != 0); + if ( roundBits ) { + sigX64 &= UINT64_C( 0xFFFFFFFFFFFFFFF8 ); + if ( exact ) slowfloat_exceptionFlags |= softfloat_flag_inexact; + if ( isTiny ) slowfloat_exceptionFlags |= softfloat_flag_underflow; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( roundBits < 4 ) goto noIncrement; + if ( (roundBits == 4) && !(sigX64 & 8) ) goto noIncrement; + break; + case softfloat_round_minMag: + goto noIncrement; + case softfloat_round_min: + if ( !xPtr->sign ) goto noIncrement; + break; + case softfloat_round_max: + if ( xPtr->sign ) goto noIncrement; + break; + case softfloat_round_near_maxMag: + if ( roundBits < 4 ) goto noIncrement; + break; +#ifdef FLOAT_ROUND_ODD + case softfloat_round_odd: + sigX64 |= 8; + goto noIncrement; +#endif + } + sigX64 += 8; + if ( sigX64 == UINT64_C( 0x0100000000000000 ) ) { + ++xPtr->exp; + sigX64 = UINT64_C( 0x0080000000000000 ); + } + noIncrement: + xPtr->sig.v64 = sigX64; + xPtr->sig.v0 = 0; + } + +} + +static +void + roundFloatXTo64( + bool isTiny, struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast64_t sigX0, roundBits, sigX64; + + sigX0 = xPtr->sig.v0; + roundBits = sigX0 & UINT64_C( 0x00FFFFFFFFFFFFFF ); + if ( roundBits ) { + sigX0 &= UINT64_C( 0xFF00000000000000 ); + if ( exact ) slowfloat_exceptionFlags |= softfloat_flag_inexact; + if ( isTiny ) slowfloat_exceptionFlags |= softfloat_flag_underflow; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( roundBits < UINT64_C( 0x0080000000000000 ) ) goto noIncrement; + if ( + (roundBits == UINT64_C( 0x0080000000000000 )) + && !(sigX0 & UINT64_C( 0x0100000000000000 )) + ) { + goto noIncrement; + } + break; + case softfloat_round_minMag: + goto noIncrement; + case softfloat_round_min: + if ( !xPtr->sign ) goto noIncrement; + break; + case softfloat_round_max: + if ( xPtr->sign ) goto noIncrement; + break; + case softfloat_round_near_maxMag: + if ( roundBits < UINT64_C( 0x0080000000000000 ) ) goto noIncrement; + break; +#ifdef FLOAT_ROUND_ODD + case softfloat_round_odd: + sigX0 |= UINT64_C( 0x100000000000000 ); + goto noIncrement; +#endif + } + sigX0 += UINT64_C( 0x100000000000000 ); + sigX64 = xPtr->sig.v64 + !sigX0; + if ( sigX64 == UINT64_C( 0x0100000000000000 ) ) { + ++xPtr->exp; + sigX64 = UINT64_C( 0x0080000000000000 ); + } + xPtr->sig.v64 = sigX64; + noIncrement: + xPtr->sig.v0 = sigX0; + } + +} + +static +void + roundFloatXTo113( + bool isTiny, struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast64_t sigX0; + uint_fast8_t roundBits; + uint_fast64_t sigX64; + + sigX0 = xPtr->sig.v0; + roundBits = sigX0 & 0x7F; + if ( roundBits ) { + sigX0 &= UINT64_C( 0xFFFFFFFFFFFFFF80 ); + if ( exact ) slowfloat_exceptionFlags |= softfloat_flag_inexact; + if ( isTiny ) slowfloat_exceptionFlags |= softfloat_flag_underflow; + switch ( roundingMode ) { + case softfloat_round_near_even: + if ( roundBits < 0x40 ) goto noIncrement; + if ( (roundBits == 0x40) && !(sigX0 & 0x80) ) goto noIncrement; + break; + case softfloat_round_minMag: + goto noIncrement; + case softfloat_round_min: + if ( !xPtr->sign ) goto noIncrement; + break; + case softfloat_round_max: + if ( xPtr->sign ) goto noIncrement; + break; + case softfloat_round_near_maxMag: + if ( roundBits < 0x40 ) goto noIncrement; + break; +#ifdef FLOAT_ROUND_ODD + case softfloat_round_odd: + sigX0 |= 0x80; + goto noIncrement; +#endif + } + sigX0 += 0x80; + sigX64 = xPtr->sig.v64 + !sigX0; + if ( sigX64 == UINT64_C( 0x0100000000000000 ) ) { + ++xPtr->exp; + sigX64 = UINT64_C( 0x0080000000000000 ); + } + xPtr->sig.v64 = sigX64; + noIncrement: + xPtr->sig.v0 = sigX0; + } + +} + +static void ui32ToFloatX( uint_fast32_t a, struct floatX *xPtr ) +{ + uint_fast64_t sig64; + int_fast32_t exp; + + xPtr->isNaN = false; + xPtr->isInf = false; + xPtr->sign = false; + sig64 = a; + if ( a ) { + xPtr->isZero = false; + exp = 31; + sig64 <<= 24; + while ( sig64 < UINT64_C( 0x0080000000000000 ) ) { + --exp; + sig64 <<= 1; + } + xPtr->exp = exp; + } else { + xPtr->isZero = true; + } + xPtr->sig.v64 = sig64; + xPtr->sig.v0 = 0; + +} + +static +uint_fast32_t + floatXToUI32( + const struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast8_t savedExceptionFlags; + struct floatX x; + int_fast32_t shiftDist; + uint_fast32_t z; + + if ( xPtr->isInf || xPtr->isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + return (xPtr->isInf && xPtr->sign) ? 0 : 0xFFFFFFFF; + } + if ( xPtr->isZero ) return 0; + savedExceptionFlags = slowfloat_exceptionFlags; + x = *xPtr; + shiftDist = 52 - x.exp; + if ( 56 < shiftDist ) { + x.sig.v64 = 0; + x.sig.v0 = 1; + } else { + while ( 0 < shiftDist ) { + x.sig = shortShiftRightJam128( x.sig, 1 ); + --shiftDist; + } + } + roundFloatXTo53( false, &x, roundingMode, exact ); + x.sig = shortShiftRightJam128( x.sig, 3 ); + z = x.sig.v64; + if ( (shiftDist < 0) || x.sig.v64>>32 || (x.sign && z) ) { + slowfloat_exceptionFlags = + savedExceptionFlags | softfloat_flag_invalid; + return x.sign ? 0 : 0xFFFFFFFF; + } + return z; + +} + +static void ui64ToFloatX( uint_fast64_t a, struct floatX *xPtr ) +{ + struct uint128 sig; + int_fast32_t exp; + + xPtr->isNaN = false; + xPtr->isInf = false; + xPtr->sign = false; + sig.v64 = 0; + sig.v0 = a; + if ( a ) { + xPtr->isZero = false; + exp = 63; + sig = shortShiftLeft128( sig, 56 ); + while ( sig.v64 < UINT64_C( 0x0080000000000000 ) ) { + --exp; + sig = shortShiftLeft128( sig, 1 ); + } + xPtr->exp = exp; + } else { + xPtr->isZero = true; + } + xPtr->sig = sig; + +} + +static +uint_fast64_t + floatXToUI64( + const struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast8_t savedExceptionFlags; + struct floatX x; + int_fast32_t shiftDist; + uint_fast64_t z; + + if ( xPtr->isInf || xPtr->isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + return + (xPtr->isInf && xPtr->sign) ? 0 : UINT64_C( 0xFFFFFFFFFFFFFFFF ); + } + if ( xPtr->isZero ) return 0; + savedExceptionFlags = slowfloat_exceptionFlags; + x = *xPtr; + shiftDist = 112 - x.exp; + if ( 116 < shiftDist ) { + x.sig.v64 = 0; + x.sig.v0 = 1; + } else { + while ( 0 < shiftDist ) { + x.sig = shortShiftRightJam128( x.sig, 1 ); + --shiftDist; + } + } + roundFloatXTo113( false, &x, roundingMode, exact ); + x.sig = shortShiftRightJam128( x.sig, 7 ); + z = x.sig.v0; + if ( (shiftDist < 0) || x.sig.v64 || (x.sign && z) ) { + slowfloat_exceptionFlags = + savedExceptionFlags | softfloat_flag_invalid; + return x.sign ? 0 : UINT64_C( 0xFFFFFFFFFFFFFFFF ); + } + return z; + +} + +static void i32ToFloatX( int_fast32_t a, struct floatX *xPtr ) +{ + bool sign; + uint_fast64_t sig64; + int_fast32_t exp; + + xPtr->isNaN = false; + xPtr->isInf = false; + sign = (a < 0); + xPtr->sign = sign; + sig64 = sign ? -(uint64_t) a : a; + if ( a ) { + xPtr->isZero = false; + exp = 31; + sig64 <<= 24; + while ( sig64 < UINT64_C( 0x0080000000000000 ) ) { + --exp; + sig64 <<= 1; + } + xPtr->exp = exp; + } else { + xPtr->isZero = true; + } + xPtr->sig.v64 = sig64; + xPtr->sig.v0 = 0; + +} + +static +int_fast32_t + floatXToI32( + const struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast8_t savedExceptionFlags; + struct floatX x; + int_fast32_t shiftDist; + union { uint32_t ui; int32_t i; } uZ; + + if ( xPtr->isInf || xPtr->isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + return (xPtr->isInf && xPtr->sign) ? -0x7FFFFFFF - 1 : 0x7FFFFFFF; + } + if ( xPtr->isZero ) return 0; + savedExceptionFlags = slowfloat_exceptionFlags; + x = *xPtr; + shiftDist = 52 - x.exp; + if ( 56 < shiftDist ) { + x.sig.v64 = 0; + x.sig.v0 = 1; + } else { + while ( 0 < shiftDist ) { + x.sig = shortShiftRightJam128( x.sig, 1 ); + --shiftDist; + } + } + roundFloatXTo53( false, &x, roundingMode, exact ); + x.sig = shortShiftRightJam128( x.sig, 3 ); + uZ.ui = x.sig.v64; + if ( x.sign ) uZ.ui = -uZ.ui; + if ( + (shiftDist < 0) || x.sig.v64>>32 + || ((uZ.i != 0) && (x.sign != (uZ.i < 0))) + ) { + slowfloat_exceptionFlags = + savedExceptionFlags | softfloat_flag_invalid; + return x.sign ? -0x7FFFFFFF - 1 : 0x7FFFFFFF; + } + return uZ.i; + +} + +static void i64ToFloatX( int_fast64_t a, struct floatX *xPtr ) +{ + bool sign; + struct uint128 sig; + int_fast32_t exp; + + xPtr->isNaN = false; + xPtr->isInf = false; + sign = (a < 0); + xPtr->sign = sign; + sig.v64 = 0; + sig.v0 = sign ? -(uint_fast64_t) a : a; + if ( a ) { + xPtr->isZero = false; + exp = 63; + sig = shortShiftLeft128( sig, 56 ); + while ( sig.v64 < UINT64_C( 0x0080000000000000 ) ) { + --exp; + sig = shortShiftLeft128( sig, 1 ); + } + xPtr->exp = exp; + } else { + xPtr->isZero = true; + } + xPtr->sig = sig; + +} + +static +int_fast64_t + floatXToI64( + const struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + uint_fast8_t savedExceptionFlags; + struct floatX x; + int_fast32_t shiftDist; + union { uint64_t ui; int64_t i; } uZ; + + if ( xPtr->isInf || xPtr->isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + return + (xPtr->isInf && xPtr->sign) ? -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1 + : INT64_C( 0x7FFFFFFFFFFFFFFF ); + } + if ( xPtr->isZero ) return 0; + savedExceptionFlags = slowfloat_exceptionFlags; + x = *xPtr; + shiftDist = 112 - x.exp; + if ( 116 < shiftDist ) { + x.sig.v64 = 0; + x.sig.v0 = 1; + } else { + while ( 0 < shiftDist ) { + x.sig = shortShiftRightJam128( x.sig, 1 ); + --shiftDist; + } + } + roundFloatXTo113( false, &x, roundingMode, exact ); + x.sig = shortShiftRightJam128( x.sig, 7 ); + uZ.ui = x.sig.v0; + if ( x.sign ) uZ.ui = -uZ.ui; + if ( + (shiftDist < 0) || x.sig.v64 || ((uZ.i != 0) && (x.sign != (uZ.i < 0))) + ) { + slowfloat_exceptionFlags = + savedExceptionFlags | softfloat_flag_invalid; + return + x.sign ? -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1 + : INT64_C( 0x7FFFFFFFFFFFFFFF ); + } + return uZ.i; + +} + +#ifdef FLOAT16 + +static void f16ToFloatX( float16_t a, struct floatX *xPtr ) +{ + union ui16_f16 uA; + uint_fast16_t uiA; + int_fast8_t exp; + uint_fast64_t sig64; + + uA.f = a; + uiA = uA.ui; + xPtr->isNaN = false; + xPtr->isInf = false; + xPtr->isZero = false; + xPtr->sign = ((uiA & 0x8000) != 0); + exp = uiA>>10 & 0x1F; + sig64 = uiA & 0x03FF; + sig64 <<= 45; + if ( exp == 0x1F ) { + if ( sig64 ) { + xPtr->isNaN = true; + } else { + xPtr->isInf = true; + } + } else if ( !exp ) { + if ( !sig64 ) { + xPtr->isZero = true; + } else { + exp = 1 - 0xF; + do { + --exp; + sig64 <<= 1; + } while ( sig64 < UINT64_C( 0x0080000000000000 ) ); + xPtr->exp = exp; + } + } else { + xPtr->exp = exp - 0xF; + sig64 |= UINT64_C( 0x0080000000000000 ); + } + xPtr->sig.v64 = sig64; + xPtr->sig.v0 = 0; + +} + +static float16_t floatXToF16( const struct floatX *xPtr ) +{ + uint_fast16_t uiZ; + struct floatX x, savedX; + bool isTiny; + int_fast32_t exp; + union ui16_f16 uZ; + + if ( xPtr->isNaN ) { + uiZ = 0xFFFF; + goto uiZ; + } + if ( xPtr->isInf ) { + uiZ = xPtr->sign ? 0xFC00 : 0x7C00; + goto uiZ; + } + if ( xPtr->isZero ) { + uiZ = xPtr->sign ? 0x8000 : 0; + goto uiZ; + } + x = *xPtr; + while ( UINT64_C( 0x0100000000000000 ) <= x.sig.v64 ) { + ++x.exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + while ( x.sig.v64 < UINT64_C( 0x0080000000000000 ) ) { + --x.exp; + x.sig = shortShiftLeft128( x.sig, 1 ); + } + savedX = x; + isTiny = + (slowfloat_detectTininess == softfloat_tininess_beforeRounding) + && (x.exp + 0xF <= 0); + roundFloatXTo11( isTiny, &x, slowfloat_roundingMode, true ); + exp = x.exp + 0xF; + if ( 0x1F <= exp ) { + slowfloat_exceptionFlags |= + softfloat_flag_overflow | softfloat_flag_inexact; + if ( x.sign ) { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_min: + case softfloat_round_near_maxMag: + uiZ = 0xFC00; + break; + case softfloat_round_minMag: + case softfloat_round_max: + case softfloat_round_odd: + uiZ = 0xFBFF; + break; + } + } else { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_max: + case softfloat_round_near_maxMag: + uiZ = 0x7C00; + break; + case softfloat_round_minMag: + case softfloat_round_min: + case softfloat_round_odd: + uiZ = 0x7BFF; + break; + } + } + goto uiZ; + } + if ( exp <= 0 ) { + isTiny = true; + x = savedX; + exp = x.exp + 0xF; + if ( exp < -14 ) { + x.sig.v0 = (x.sig.v64 != 0) || (x.sig.v0 != 0); + x.sig.v64 = 0; + } else { + while ( exp <= 0 ) { + ++exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + } + roundFloatXTo11( isTiny, &x, slowfloat_roundingMode, true ); + exp = (UINT64_C( 0x0080000000000000 ) <= x.sig.v64) ? 1 : 0; + } + uiZ = (uint_fast16_t) exp<<10; + if ( x.sign ) uiZ |= 0x8000; + uiZ |= x.sig.v64>>45 & 0x03FF; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + +static void f32ToFloatX( float32_t a, struct floatX *xPtr ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast64_t sig64; + + uA.f = a; + uiA = uA.ui; + xPtr->isNaN = false; + xPtr->isInf = false; + xPtr->isZero = false; + xPtr->sign = ((uiA & 0x80000000) != 0); + exp = uiA>>23 & 0xFF; + sig64 = uiA & 0x007FFFFF; + sig64 <<= 32; + if ( exp == 0xFF ) { + if ( sig64 ) { + xPtr->isNaN = true; + } else { + xPtr->isInf = true; + } + } else if ( !exp ) { + if ( !sig64 ) { + xPtr->isZero = true; + } else { + exp = 1 - 0x7F; + do { + --exp; + sig64 <<= 1; + } while ( sig64 < UINT64_C( 0x0080000000000000 ) ); + xPtr->exp = exp; + } + } else { + xPtr->exp = exp - 0x7F; + sig64 |= UINT64_C( 0x0080000000000000 ); + } + xPtr->sig.v64 = sig64; + xPtr->sig.v0 = 0; + +} + +static float32_t floatXToF32( const struct floatX *xPtr ) +{ + uint_fast32_t uiZ; + struct floatX x, savedX; + bool isTiny; + int_fast32_t exp; + union ui32_f32 uZ; + + if ( xPtr->isNaN ) { + uiZ = 0xFFFFFFFF; + goto uiZ; + } + if ( xPtr->isInf ) { + uiZ = xPtr->sign ? 0xFF800000 : 0x7F800000; + goto uiZ; + } + if ( xPtr->isZero ) { + uiZ = xPtr->sign ? 0x80000000 : 0; + goto uiZ; + } + x = *xPtr; + while ( UINT64_C( 0x0100000000000000 ) <= x.sig.v64 ) { + ++x.exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + while ( x.sig.v64 < UINT64_C( 0x0080000000000000 ) ) { + --x.exp; + x.sig = shortShiftLeft128( x.sig, 1 ); + } + savedX = x; + isTiny = + (slowfloat_detectTininess == softfloat_tininess_beforeRounding) + && (x.exp + 0x7F <= 0); + roundFloatXTo24( isTiny, &x, slowfloat_roundingMode, true ); + exp = x.exp + 0x7F; + if ( 0xFF <= exp ) { + slowfloat_exceptionFlags |= + softfloat_flag_overflow | softfloat_flag_inexact; + if ( x.sign ) { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_min: + case softfloat_round_near_maxMag: + uiZ = 0xFF800000; + break; + case softfloat_round_minMag: + case softfloat_round_max: + case softfloat_round_odd: + uiZ = 0xFF7FFFFF; + break; + } + } else { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_max: + case softfloat_round_near_maxMag: + uiZ = 0x7F800000; + break; + case softfloat_round_minMag: + case softfloat_round_min: + case softfloat_round_odd: + uiZ = 0x7F7FFFFF; + break; + } + } + goto uiZ; + } + if ( exp <= 0 ) { + isTiny = true; + x = savedX; + exp = x.exp + 0x7F; + if ( exp < -27 ) { + x.sig.v0 = (x.sig.v64 != 0) || (x.sig.v0 != 0); + x.sig.v64 = 0; + } else { + while ( exp <= 0 ) { + ++exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + } + roundFloatXTo24( isTiny, &x, slowfloat_roundingMode, true ); + exp = (UINT64_C( 0x0080000000000000 ) <= x.sig.v64) ? 1 : 0; + } + uiZ = (uint_fast32_t) exp<<23; + if ( x.sign ) uiZ |= 0x80000000; + uiZ |= x.sig.v64>>32 & 0x007FFFFF; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#ifdef FLOAT64 + +static void f64ToFloatX( float64_t a, struct floatX *xPtr ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t sig64; + + uA.f = a; + uiA = uA.ui; + xPtr->isNaN = false; + xPtr->isInf = false; + xPtr->isZero = false; + xPtr->sign = ((uiA & UINT64_C( 0x8000000000000000 )) != 0); + exp = uiA>>52 & 0x7FF; + sig64 = uiA & UINT64_C( 0x000FFFFFFFFFFFFF ); + if ( exp == 0x7FF ) { + if ( sig64 ) { + xPtr->isNaN = true; + } else { + xPtr->isInf = true; + } + } else if ( !exp ) { + if ( !sig64 ) { + xPtr->isZero = true; + } else { + exp = 1 - 0x3FF; + do { + --exp; + sig64 <<= 1; + } while ( sig64 < UINT64_C( 0x0010000000000000 ) ); + xPtr->exp = exp; + } + } else { + xPtr->exp = exp - 0x3FF; + sig64 |= UINT64_C( 0x0010000000000000 ); + } + xPtr->sig.v64 = sig64<<3; + xPtr->sig.v0 = 0; + +} + +static float64_t floatXToF64( const struct floatX *xPtr ) +{ + uint_fast64_t uiZ; + struct floatX x, savedX; + bool isTiny; + int_fast32_t exp; + union ui64_f64 uZ; + + if ( xPtr->isNaN ) { + uiZ = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + goto uiZ; + } + if ( xPtr->isInf ) { + uiZ = + xPtr->sign ? UINT64_C( 0xFFF0000000000000 ) + : UINT64_C( 0x7FF0000000000000 ); + goto uiZ; + } + if ( xPtr->isZero ) { + uiZ = xPtr->sign ? UINT64_C( 0x8000000000000000 ) : 0; + goto uiZ; + } + x = *xPtr; + while ( UINT64_C( 0x0100000000000000 ) <= x.sig.v64 ) { + ++x.exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + while ( x.sig.v64 < UINT64_C( 0x0080000000000000 ) ) { + --x.exp; + x.sig = shortShiftLeft128( x.sig, 1 ); + } + savedX = x; + isTiny = + (slowfloat_detectTininess == softfloat_tininess_beforeRounding) + && (x.exp + 0x3FF <= 0); + roundFloatXTo53( isTiny, &x, slowfloat_roundingMode, true ); + exp = x.exp + 0x3FF; + if ( 0x7FF <= exp ) { + slowfloat_exceptionFlags |= + softfloat_flag_overflow | softfloat_flag_inexact; + if ( x.sign ) { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_min: + case softfloat_round_near_maxMag: + uiZ = UINT64_C( 0xFFF0000000000000 ); + break; + case softfloat_round_minMag: + case softfloat_round_max: + case softfloat_round_odd: + uiZ = UINT64_C( 0xFFEFFFFFFFFFFFFF ); + break; + } + } else { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_max: + case softfloat_round_near_maxMag: + uiZ = UINT64_C( 0x7FF0000000000000 ); + break; + case softfloat_round_minMag: + case softfloat_round_min: + case softfloat_round_odd: + uiZ = UINT64_C( 0x7FEFFFFFFFFFFFFF ); + break; + } + } + goto uiZ; + } + if ( exp <= 0 ) { + isTiny = true; + x = savedX; + exp = x.exp + 0x3FF; + if ( exp < -56 ) { + x.sig.v0 = (x.sig.v64 != 0) || (x.sig.v0 != 0); + x.sig.v64 = 0; + } else { + while ( exp <= 0 ) { + ++exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + } + roundFloatXTo53( isTiny, &x, slowfloat_roundingMode, true ); + exp = (UINT64_C( 0x0080000000000000 ) <= x.sig.v64) ? 1 : 0; + } + uiZ = (uint_fast64_t) exp<<52; + if ( x.sign ) uiZ |= UINT64_C( 0x8000000000000000 ); + uiZ |= x.sig.v64>>3 & UINT64_C( 0x000FFFFFFFFFFFFF ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + +#endif + +#ifdef EXTFLOAT80 + +static void extF80MToFloatX( const extFloat80_t *aPtr, struct floatX *xPtr ) +{ + const struct extFloat80M *aSPtr; + uint_fast16_t uiA64; + int_fast32_t exp; + struct uint128 sig; + + aSPtr = (const struct extFloat80M *) aPtr; + xPtr->isNaN = false; + xPtr->isInf = false; + xPtr->isZero = false; + uiA64 = aSPtr->signExp; + xPtr->sign = ((uiA64 & 0x8000) != 0); + exp = uiA64 & 0x7FFF; + sig.v64 = 0; + sig.v0 = aSPtr->signif; + if ( exp == 0x7FFF ) { + if ( sig.v0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) { + xPtr->isNaN = true; + } else { + xPtr->isInf = true; + } + } else { + if ( !exp ) ++exp; + exp -= 0x3FFF; + if ( !(sig.v0 & UINT64_C( 0x8000000000000000 )) ) { + if ( !sig.v0 ) { + xPtr->isZero = true; + } else { + do { + --exp; + sig.v0 <<= 1; + } while ( sig.v0 < UINT64_C( 0x8000000000000000 ) ); + } + } + xPtr->exp = exp; + } + xPtr->sig = shortShiftLeft128( sig, 56 ); + +} + +static void floatXToExtF80M( const struct floatX *xPtr, extFloat80_t *zPtr ) +{ + struct extFloat80M *zSPtr; + struct floatX x, savedX; + bool isTiny; + int_fast32_t exp; + uint_fast64_t uiZ0; + uint_fast16_t uiZ64; + + zSPtr = (struct extFloat80M *) zPtr; + if ( xPtr->isNaN ) { + zSPtr->signExp = 0xFFFF; + zSPtr->signif = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + return; + } + if ( xPtr->isInf ) { + zSPtr->signExp = xPtr->sign ? 0xFFFF : 0x7FFF; + zSPtr->signif = UINT64_C( 0x8000000000000000 ); + return; + } + if ( xPtr->isZero ) { + zSPtr->signExp = xPtr->sign ? 0x8000 : 0; + zSPtr->signif = 0; + return; + } + x = *xPtr; + while ( UINT64_C( 0x0100000000000000 ) <= x.sig.v64 ) { + ++x.exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + while ( x.sig.v64 < UINT64_C( 0x0080000000000000 ) ) { + --x.exp; + x.sig = shortShiftLeft128( x.sig, 1 ); + } + savedX = x; + isTiny = + (slowfloat_detectTininess == softfloat_tininess_beforeRounding) + && (x.exp + 0x3FFF <= 0); + switch ( slow_extF80_roundingPrecision ) { + case 32: + roundFloatXTo24( isTiny, &x, slowfloat_roundingMode, true ); + break; + case 64: + roundFloatXTo53( isTiny, &x, slowfloat_roundingMode, true ); + break; + default: + roundFloatXTo64( isTiny, &x, slowfloat_roundingMode, true ); + break; + } + exp = x.exp + 0x3FFF; + if ( 0x7FFF <= exp ) { + slowfloat_exceptionFlags |= + softfloat_flag_overflow | softfloat_flag_inexact; + if ( x.sign ) { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_min: + case softfloat_round_near_maxMag: + zSPtr->signExp = 0xFFFF; + zSPtr->signif = UINT64_C( 0x8000000000000000 ); + break; + case softfloat_round_minMag: + case softfloat_round_max: + case softfloat_round_odd: + switch ( slow_extF80_roundingPrecision ) { + case 32: + uiZ0 = UINT64_C( 0xFFFFFF0000000000 ); + break; + case 64: + uiZ0 = UINT64_C( 0xFFFFFFFFFFFFF800 ); + break; + default: + uiZ0 = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + break; + } + zSPtr->signExp = 0xFFFE; + zSPtr->signif = uiZ0; + break; + } + } else { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_max: + case softfloat_round_near_maxMag: + zSPtr->signExp = 0x7FFF; + zSPtr->signif = UINT64_C( 0x8000000000000000 ); + break; + case softfloat_round_minMag: + case softfloat_round_min: + case softfloat_round_odd: + switch ( slow_extF80_roundingPrecision ) { + case 32: + uiZ0 = UINT64_C( 0xFFFFFF0000000000 ); + break; + case 64: + uiZ0 = UINT64_C( 0xFFFFFFFFFFFFF800 ); + break; + default: + uiZ0 = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + break; + } + zSPtr->signExp = 0x7FFE; + zSPtr->signif = uiZ0; + break; + } + } + return; + } + if ( exp <= 0 ) { + isTiny = true; + x = savedX; + exp = x.exp + 0x3FFF; + if ( exp < -70 ) { + x.sig.v0 = (x.sig.v64 != 0) || (x.sig.v0 != 0); + x.sig.v64 = 0; + } else { + while ( exp <= 0 ) { + ++exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + } + switch ( slow_extF80_roundingPrecision ) { + case 32: + roundFloatXTo24( isTiny, &x, slowfloat_roundingMode, true ); + break; + case 64: + roundFloatXTo53( isTiny, &x, slowfloat_roundingMode, true ); + break; + default: + roundFloatXTo64( isTiny, &x, slowfloat_roundingMode, true ); + break; + } + exp = (UINT64_C( 0x0080000000000000 ) <= x.sig.v64) ? 1 : 0; + } + uiZ64 = exp; + if ( x.sign ) uiZ64 |= 0x8000; + zSPtr->signExp = uiZ64; + zSPtr->signif = shortShiftRightJam128( x.sig, 56 ).v0; + +} + +#endif + +#ifdef FLOAT128 + +static void f128MToFloatX( const float128_t *aPtr, struct floatX *xPtr ) +{ + const struct uint128 *uiAPtr; + uint_fast64_t uiA64; + int_fast32_t exp; + struct uint128 sig; + + uiAPtr = (const struct uint128 *) aPtr; + xPtr->isNaN = false; + xPtr->isInf = false; + xPtr->isZero = false; + uiA64 = uiAPtr->v64; + xPtr->sign = ((uiA64 & UINT64_C( 0x8000000000000000 )) != 0); + exp = uiA64>>48 & 0x7FFF; + sig.v64 = uiA64 & UINT64_C( 0x0000FFFFFFFFFFFF ); + sig.v0 = uiAPtr->v0; + if ( exp == 0x7FFF ) { + if ( sig.v64 || sig.v0 ) { + xPtr->isNaN = true; + } else { + xPtr->isInf = true; + } + } else if ( !exp ) { + if ( !sig.v64 && !sig.v0 ) { + xPtr->isZero = true; + } else { + exp = 1 - 0x3FFF; + do { + --exp; + sig = shortShiftLeft128( sig, 1 ); + } while ( sig.v64 < UINT64_C( 0x0001000000000000 ) ); + xPtr->exp = exp; + } + } else { + xPtr->exp = exp - 0x3FFF; + sig.v64 |= UINT64_C( 0x0001000000000000 ); + } + xPtr->sig = shortShiftLeft128( sig, 7 ); + +} + +static void floatXToF128M( const struct floatX *xPtr, float128_t *zPtr ) +{ + struct uint128 *uiZPtr; + struct floatX x, savedX; + bool isTiny; + int_fast32_t exp; + uint_fast64_t uiZ64; + + uiZPtr = (struct uint128 *) zPtr; + if ( xPtr->isNaN ) { + uiZPtr->v64 = uiZPtr->v0 = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + return; + } + if ( xPtr->isInf ) { + uiZPtr->v64 = + xPtr->sign ? UINT64_C( 0xFFFF000000000000 ) + : UINT64_C( 0x7FFF000000000000 ); + uiZPtr->v0 = 0; + return; + } + if ( xPtr->isZero ) { + uiZPtr->v64 = xPtr->sign ? UINT64_C( 0x8000000000000000 ) : 0; + uiZPtr->v0 = 0; + return; + } + x = *xPtr; + while ( UINT64_C( 0x0100000000000000 ) <= x.sig.v64 ) { + ++x.exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + while ( x.sig.v64 < UINT64_C( 0x0080000000000000 ) ) { + --x.exp; + x.sig = shortShiftLeft128( x.sig, 1 ); + } + savedX = x; + isTiny = + (slowfloat_detectTininess == softfloat_tininess_beforeRounding) + && (x.exp + 0x3FFF <= 0); + roundFloatXTo113( isTiny, &x, slowfloat_roundingMode, true ); + exp = x.exp + 0x3FFF; + if ( 0x7FFF <= exp ) { + slowfloat_exceptionFlags |= + softfloat_flag_overflow | softfloat_flag_inexact; + if ( x.sign ) { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_min: + case softfloat_round_near_maxMag: + uiZPtr->v64 = UINT64_C( 0xFFFF000000000000 ); + uiZPtr->v0 = 0; + break; + case softfloat_round_minMag: + case softfloat_round_max: + case softfloat_round_odd: + uiZPtr->v64 = UINT64_C( 0xFFFEFFFFFFFFFFFF ); + uiZPtr->v0 = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + break; + } + } else { + switch ( slowfloat_roundingMode ) { + case softfloat_round_near_even: + case softfloat_round_max: + case softfloat_round_near_maxMag: + uiZPtr->v64 = UINT64_C( 0x7FFF000000000000 ); + uiZPtr->v0 = 0; + break; + case softfloat_round_minMag: + case softfloat_round_min: + case softfloat_round_odd: + uiZPtr->v64 = UINT64_C( 0x7FFEFFFFFFFFFFFF ); + uiZPtr->v0 = UINT64_C( 0xFFFFFFFFFFFFFFFF ); + break; + } + } + return; + } + if ( exp <= 0 ) { + isTiny = true; + x = savedX; + exp = x.exp + 0x3FFF; + if ( exp < -120 ) { + x.sig.v0 = (x.sig.v64 != 0) || (x.sig.v0 != 0); + x.sig.v64 = 0; + } else { + while ( exp <= 0 ) { + ++exp; + x.sig = shortShiftRightJam128( x.sig, 1 ); + } + } + roundFloatXTo113( isTiny, &x, slowfloat_roundingMode, true ); + exp = (UINT64_C( 0x0080000000000000 ) <= x.sig.v64) ? 1 : 0; + } + uiZ64 = (uint_fast64_t) exp<<48; + if ( x.sign ) uiZ64 |= UINT64_C( 0x8000000000000000 ); + x.sig = shortShiftRightJam128( x.sig, 7 ); + uiZPtr->v64 = uiZ64 | (x.sig.v64 & UINT64_C( 0x0000FFFFFFFFFFFF )); + uiZPtr->v0 = x.sig.v0; + +} + +#endif + +static void floatXInvalid( struct floatX *xPtr ) +{ + + slowfloat_exceptionFlags |= softfloat_flag_invalid; + *xPtr = floatXNaN; + +} + +static +void + floatXRoundToInt( struct floatX *xPtr, uint_fast8_t roundingMode, bool exact ) +{ + int_fast32_t exp, shiftDist; + struct uint128 sig; + + if ( xPtr->isNaN || xPtr->isInf ) return; + exp = xPtr->exp; + shiftDist = 112 - exp; + if ( shiftDist <= 0 ) return; + if ( 119 < shiftDist ) { + xPtr->exp = 112; + xPtr->sig.v64 = 0; + xPtr->sig.v0 = !xPtr->isZero; + } else { + sig = xPtr->sig; + while ( 0 < shiftDist ) { + ++exp; + sig = shortShiftRightJam128( sig, 1 ); + --shiftDist; + } + xPtr->exp = exp; + xPtr->sig = sig; + } + roundFloatXTo113( false, xPtr, roundingMode, exact ); + if ( !xPtr->sig.v64 && !xPtr->sig.v0 ) xPtr->isZero = true; + +} + +static void floatXAdd( struct floatX *xPtr, const struct floatX *yPtr ) +{ + int_fast32_t expX, expY, expDiff; + struct uint128 sigY; + + if ( xPtr->isNaN ) return; + if ( yPtr->isNaN ) goto copyY; + if ( xPtr->isInf && yPtr->isInf ) { + if ( xPtr->sign != yPtr->sign ) floatXInvalid( xPtr ); + return; + } + if ( xPtr->isInf ) return; + if ( yPtr->isInf ) goto copyY; + if ( xPtr->isZero && yPtr->isZero ) { + if ( xPtr->sign == yPtr->sign ) return; + goto completeCancellation; + } + expX = xPtr->exp; + expY = yPtr->exp; + if ( + (xPtr->sign != yPtr->sign) && (expX == expY) + && eq128( xPtr->sig, yPtr->sig ) + ) { + completeCancellation: + if (slowfloat_roundingMode == softfloat_round_min) { + *xPtr = floatXNegativeZero; + } else { + *xPtr = floatXPositiveZero; + } + return; + } + if ( xPtr->isZero ) goto copyY; + if ( yPtr->isZero ) return; + expDiff = expX - expY; + if ( expDiff < 0 ) { + xPtr->exp = expY; + if ( expDiff < -120 ) { + xPtr->sig.v64 = 0; + xPtr->sig.v0 = 1; + } else { + while ( expDiff < 0 ) { + ++expDiff; + xPtr->sig = shortShiftRightJam128( xPtr->sig, 1 ); + } + } + if ( xPtr->sign != yPtr->sign ) xPtr->sig = neg128( xPtr->sig ); + xPtr->sign = yPtr->sign; + xPtr->sig = add128( xPtr->sig, yPtr->sig ); + } else { + sigY = yPtr->sig; + if ( 120 < expDiff ) { + sigY.v64 = 0; + sigY.v0 = 1; + } else { + while ( 0 < expDiff ) { + --expDiff; + sigY = shortShiftRightJam128( sigY, 1 ); + } + } + if ( xPtr->sign != yPtr->sign ) sigY = neg128( sigY ); + xPtr->sig = add128( xPtr->sig, sigY ); + } + if ( xPtr->sig.v64 & UINT64_C( 0x8000000000000000 ) ) { + xPtr->sign = !xPtr->sign; + xPtr->sig = neg128( xPtr->sig ); + } + return; + copyY: + *xPtr = *yPtr; + +} + +static void floatXMul( struct floatX *xPtr, const struct floatX *yPtr ) +{ + struct uint128 sig; + int bitNum; + + if ( xPtr->isNaN ) return; + if ( yPtr->isNaN ) { + xPtr->isNaN = true; + xPtr->isInf = false; + xPtr->isZero = false; + xPtr->sign = yPtr->sign; + return; + } + if ( yPtr->sign ) xPtr->sign = !xPtr->sign; + if ( xPtr->isInf ) { + if ( yPtr->isZero ) floatXInvalid( xPtr ); + return; + } + if ( yPtr->isInf ) { + if ( xPtr->isZero ) { + floatXInvalid( xPtr ); + return; + } + xPtr->isInf = true; + return; + } + if ( xPtr->isZero || yPtr->isZero ) { + if ( xPtr->sign ) { + *xPtr = floatXNegativeZero; + } else { + *xPtr = floatXPositiveZero; + } + return; + } + xPtr->exp += yPtr->exp; + sig.v64 = 0; + sig.v0 = 0; + for ( bitNum = 0; bitNum < 120; ++bitNum ) { + sig = shortShiftRightJam128( sig, 1 ); + if ( xPtr->sig.v0 & 1 ) sig = add128( sig, yPtr->sig ); + xPtr->sig = shortShiftRight128( xPtr->sig, 1 ); + } + if ( UINT64_C( 0x0100000000000000 ) <= sig.v64 ) { + ++xPtr->exp; + sig = shortShiftRightJam128( sig, 1 ); + } + xPtr->sig = sig; + +} + +static void floatXDiv( struct floatX *xPtr, const struct floatX *yPtr ) +{ + struct uint128 sig, negSigY; + int bitNum; + + if ( xPtr->isNaN ) return; + if ( yPtr->isNaN ) { + xPtr->isNaN = true; + xPtr->isInf = false; + xPtr->isZero = false; + xPtr->sign = yPtr->sign; + return; + } + if ( yPtr->sign ) xPtr->sign = !xPtr->sign; + if ( xPtr->isInf ) { + if ( yPtr->isInf ) floatXInvalid( xPtr ); + return; + } + if ( yPtr->isZero ) { + if ( xPtr->isZero ) { + floatXInvalid( xPtr ); + return; + } + slowfloat_exceptionFlags |= softfloat_flag_infinite; + xPtr->isInf = true; + return; + } + if ( xPtr->isZero || yPtr->isInf ) { + if ( xPtr->sign ) { + *xPtr = floatXNegativeZero; + } else { + *xPtr = floatXPositiveZero; + } + return; + } + xPtr->exp -= yPtr->exp + 1; + sig.v64 = 0; + sig.v0 = 0; + negSigY = neg128( yPtr->sig ); + for ( bitNum = 0; bitNum < 120; ++bitNum ) { + if ( le128( yPtr->sig, xPtr->sig ) ) { + sig.v0 |= 1; + xPtr->sig = add128( xPtr->sig, negSigY ); + } + xPtr->sig = shortShiftLeft128( xPtr->sig, 1 ); + sig = shortShiftLeft128( sig, 1 ); + } + if ( xPtr->sig.v64 || xPtr->sig.v0 ) sig.v0 |= 1; + xPtr->sig = sig; + +} + +static void floatXRem( struct floatX *xPtr, const struct floatX *yPtr ) +{ + int_fast32_t expX, expY; + struct uint128 sigY, negSigY; + bool lastQuotientBit; + struct uint128 savedSigX; + + if ( xPtr->isNaN ) return; + if ( yPtr->isNaN ) { + xPtr->isNaN = true; + xPtr->isInf = false; + xPtr->isZero = false; + xPtr->sign = yPtr->sign; + return; + } + if ( xPtr->isInf || yPtr->isZero ) { + floatXInvalid( xPtr ); + return; + } + if ( xPtr->isZero || yPtr->isInf ) return; + expX = xPtr->exp; + expY = yPtr->exp - 1; + if ( expX < expY ) return; + sigY = shortShiftLeft128( yPtr->sig, 1 ); + negSigY = neg128( sigY ); + while ( expY < expX ) { + --expX; + if ( le128( sigY, xPtr->sig ) ) { + xPtr->sig = add128( xPtr->sig, negSigY ); + } + xPtr->sig = shortShiftLeft128( xPtr->sig, 1 ); + } + xPtr->exp = expX; + lastQuotientBit = le128( sigY, xPtr->sig ); + if ( lastQuotientBit ) xPtr->sig = add128( xPtr->sig, negSigY ); + savedSigX = xPtr->sig; + xPtr->sig = neg128( add128( xPtr->sig, negSigY ) ); + if ( lt128( xPtr->sig, savedSigX ) ) { + xPtr->sign = !xPtr->sign; + } else if ( lt128( savedSigX, xPtr->sig ) ) { + goto restoreSavedSigX; + } else { + if ( lastQuotientBit ) { + xPtr->sign = !xPtr->sign; + } else { + restoreSavedSigX: + xPtr->sig = savedSigX; + } + } + if ( !xPtr->sig.v64 && !xPtr->sig.v0 ) xPtr->isZero = true; + +} + +static void floatXSqrt( struct floatX *xPtr ) +{ + struct uint128 sig, bitSig; + int bitNum; + struct uint128 savedSigX; + + if ( xPtr->isNaN || xPtr->isZero ) return; + if ( xPtr->sign ) { + floatXInvalid( xPtr ); + return; + } + if ( xPtr->isInf ) return; + if ( !(xPtr->exp & 1) ) xPtr->sig = shortShiftRightJam128( xPtr->sig, 1 ); + xPtr->exp >>= 1; + sig.v64 = 0; + sig.v0 = 0; + bitSig.v64 = UINT64_C( 0x0080000000000000 ); + bitSig.v0 = 0; + for ( bitNum = 0; bitNum < 120; ++bitNum ) { + savedSigX = xPtr->sig; + xPtr->sig = add128( xPtr->sig, neg128( sig ) ); + xPtr->sig = shortShiftLeft128( xPtr->sig, 1 ); + xPtr->sig = add128( xPtr->sig, neg128( bitSig ) ); + if ( xPtr->sig.v64 & UINT64_C( 0x8000000000000000 ) ) { + xPtr->sig = shortShiftLeft128( savedSigX, 1 ); + } else { + sig.v64 |= bitSig.v64; + sig.v0 |= bitSig.v0; + } + bitSig = shortShiftRightJam128( bitSig, 1 ); + } + if ( xPtr->sig.v64 || xPtr->sig.v0 ) sig.v0 |= 1; + xPtr->sig = sig; + +} + +static bool floatXEq( const struct floatX *xPtr, const struct floatX *yPtr ) +{ + + if ( xPtr->isNaN || yPtr->isNaN ) return false; + if ( xPtr->isZero && yPtr->isZero ) return true; + if ( xPtr->sign != yPtr->sign ) return false; + if ( xPtr->isInf || yPtr->isInf ) return xPtr->isInf && yPtr->isInf; + return ( xPtr->exp == yPtr->exp ) && eq128( xPtr->sig, yPtr->sig ); + +} + +static bool floatXLe( const struct floatX *xPtr, const struct floatX *yPtr ) +{ + + if ( xPtr->isNaN || yPtr->isNaN ) return false; + if ( xPtr->isZero && yPtr->isZero ) return true; + if ( xPtr->sign != yPtr->sign ) return xPtr->sign; + if ( xPtr->sign ) { + if ( xPtr->isInf || yPtr->isZero ) return true; + if ( yPtr->isInf || xPtr->isZero ) return false; + if ( yPtr->exp < xPtr->exp ) return true; + if ( xPtr->exp < yPtr->exp ) return false; + return le128( yPtr->sig, xPtr->sig ); + } else { + if ( yPtr->isInf || xPtr->isZero ) return true; + if ( xPtr->isInf || yPtr->isZero ) return false; + if ( xPtr->exp < yPtr->exp ) return true; + if ( yPtr->exp < xPtr->exp ) return false; + return le128( xPtr->sig, yPtr->sig ); + } + +} + +static bool floatXLt( const struct floatX *xPtr, const struct floatX *yPtr ) +{ + + if ( xPtr->isNaN || yPtr->isNaN ) return false; + if ( xPtr->isZero && yPtr->isZero ) return false; + if ( xPtr->sign != yPtr->sign ) return xPtr->sign; + if ( xPtr->isInf && yPtr->isInf ) return false; + if ( xPtr->sign ) { + if ( xPtr->isInf || yPtr->isZero ) return true; + if ( yPtr->isInf || xPtr->isZero ) return false; + if ( yPtr->exp < xPtr->exp ) return true; + if ( xPtr->exp < yPtr->exp ) return false; + return lt128( yPtr->sig, xPtr->sig ); + } else { + if ( yPtr->isInf || xPtr->isZero ) return true; + if ( xPtr->isInf || yPtr->isZero ) return false; + if ( xPtr->exp < yPtr->exp ) return true; + if ( yPtr->exp < xPtr->exp ) return false; + return lt128( xPtr->sig, yPtr->sig ); + } + +} + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +#if defined EXTFLOAT80 || defined FLOAT128 + +#ifdef LITTLEENDIAN +struct uint256 { uint64_t v0, v64, v128, v192; }; +#else +struct uint256 { uint64_t v192, v128, v64, v0; }; +#endif + +static bool eq256M( const struct uint256 *aPtr, const struct uint256 *bPtr ) +{ + + return + (aPtr->v192 == bPtr->v192) && (aPtr->v128 == bPtr->v128) + && (aPtr->v64 == bPtr->v64) && (aPtr->v0 == bPtr->v0); + +} + +static void shiftLeft1256M( struct uint256 *ptr ) +{ + uint64_t dword1, dword2; + + dword1 = ptr->v128; + ptr->v192 = ptr->v192<<1 | dword1>>63; + dword2 = ptr->v64; + ptr->v128 = dword1<<1 | dword2>>63; + dword1 = ptr->v0; + ptr->v64 = dword2<<1 | dword1>>63; + ptr->v0 = dword1<<1; + +} + +static void shiftRight1256M( struct uint256 *ptr ) +{ + uint64_t dword1, dword2; + + dword1 = ptr->v64; + ptr->v0 = dword1<<63 | ptr->v0>>1; + dword2 = ptr->v128; + ptr->v64 = dword2<<63 | dword1>>1; + dword1 = ptr->v192; + ptr->v128 = dword1<<63 | dword2>>1; + ptr->v192 = dword1>>1; + +} + +static void shiftRight1Jam256M( struct uint256 *ptr ) +{ + int extra; + + extra = ptr->v0 & 1; + shiftRight1256M( ptr ); + ptr->v0 |= extra; + +} + +static void neg256M( struct uint256 *ptr ) +{ + uint64_t v64, v0, v128; + + v64 = ptr->v64; + v0 = ptr->v0; + if ( v64 | v0 ) { + ptr->v192 = ~ptr->v192; + ptr->v128 = ~ptr->v128; + if ( v0 ) { + ptr->v64 = ~v64; + ptr->v0 = -v0; + } else { + ptr->v64 = -v64; + } + } else { + v128 = ptr->v128; + if ( v128 ) { + ptr->v192 = ~ptr->v192; + ptr->v128 = -v128; + } else { + ptr->v192 = -ptr->v192; + } + } + +} + +static void add256M( struct uint256 *aPtr, const struct uint256 *bPtr ) +{ + uint64_t dwordA, dwordZ; + unsigned int carry1, carry2; + + dwordA = aPtr->v0; + dwordZ = dwordA + bPtr->v0; + carry1 = (dwordZ < dwordA); + aPtr->v0 = dwordZ; + dwordA = aPtr->v64; + dwordZ = dwordA + bPtr->v64; + carry2 = (dwordZ < dwordA); + dwordZ += carry1; + carry2 += (dwordZ < carry1); + aPtr->v64 = dwordZ; + dwordA = aPtr->v128; + dwordZ = dwordA + bPtr->v128; + carry1 = (dwordZ < dwordA); + dwordZ += carry2; + carry1 += (dwordZ < carry2); + aPtr->v128 = dwordZ; + aPtr->v192 = aPtr->v192 + bPtr->v192 + carry1; + +} + +struct floatX256 { + bool isNaN; + bool isInf; + bool isZero; + bool sign; + int_fast32_t exp; + struct uint256 sig; +}; + +static const struct floatX256 floatX256NaN = + { true, false, false, false, 0, { 0, 0, 0, 0 } }; +static const struct floatX256 floatX256PositiveZero = + { false, false, true, false, 0, { 0, 0, 0, 0 } }; +static const struct floatX256 floatX256NegativeZero = + { false, false, true, true, 0, { 0, 0, 0, 0 } }; + +#ifdef FLOAT128 + +static void f128MToFloatX256( const float128_t *aPtr, struct floatX256 *xPtr ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + xPtr->isNaN = x.isNaN; + xPtr->isInf = x.isInf; + xPtr->isZero = x.isZero; + xPtr->sign = x.sign; + xPtr->exp = x.exp; + xPtr->sig.v192 = x.sig.v64; + xPtr->sig.v128 = x.sig.v0; + xPtr->sig.v64 = 0; + xPtr->sig.v0 = 0; + +} + +static void floatX256ToF128M( const struct floatX256 *xPtr, float128_t *zPtr ) +{ + struct floatX x; + int_fast32_t expZ; + struct uint256 sig; + + x.isNaN = xPtr->isNaN; + x.isInf = xPtr->isInf; + x.isZero = xPtr->isZero; + x.sign = xPtr->sign; + if ( !(x.isNaN | x.isInf | x.isZero) ) { + expZ = xPtr->exp; + sig = xPtr->sig; + while ( !sig.v192 ) { + expZ -= 64; + sig.v192 = sig.v128; + sig.v128 = sig.v64; + sig.v64 = sig.v0; + sig.v0 = 0; + } + while ( sig.v192 < UINT64_C( 0x0100000000000000 ) ) { + --expZ; + shiftLeft1256M( &sig ); + } + x.exp = expZ; + x.sig.v64 = sig.v192; + x.sig.v0 = sig.v128 | ((sig.v64 | sig.v0) != 0); + } + floatXToF128M( &x, zPtr ); + +} + +#endif + +static void floatX256Invalid( struct floatX256 *xPtr ) +{ + + slowfloat_exceptionFlags |= softfloat_flag_invalid; + *xPtr = floatX256NaN; + +} + +static +void floatX256Add( struct floatX256 *xPtr, const struct floatX256 *yPtr ) +{ + int_fast32_t expX, expY, expDiff; + struct uint256 sigY; + + if ( xPtr->isNaN ) return; + if ( yPtr->isNaN ) goto copyY; + if ( xPtr->isInf && yPtr->isInf ) { + if ( xPtr->sign != yPtr->sign ) floatX256Invalid( xPtr ); + return; + } + if ( xPtr->isInf ) return; + if ( yPtr->isInf ) goto copyY; + if ( xPtr->isZero && yPtr->isZero ) { + if ( xPtr->sign == yPtr->sign ) return; + goto completeCancellation; + } + expX = xPtr->exp; + expY = yPtr->exp; + if ( + (xPtr->sign != yPtr->sign) && (expX == expY) + && eq256M( &xPtr->sig, &yPtr->sig ) + ) { + completeCancellation: + if (slowfloat_roundingMode == softfloat_round_min) { + *xPtr = floatX256NegativeZero; + } else { + *xPtr = floatX256PositiveZero; + } + return; + } + if ( xPtr->isZero ) goto copyY; + if ( yPtr->isZero ) return; + expDiff = expX - expY; + if ( expDiff < 0 ) { + xPtr->exp = expY; + if ( expDiff < -248 ) { + xPtr->sig.v192 = 0; + xPtr->sig.v128 = 0; + xPtr->sig.v64 = 0; + xPtr->sig.v0 = 1; + } else { + while ( expDiff < 0 ) { + ++expDiff; + shiftRight1Jam256M( &xPtr->sig ); + } + } + if ( xPtr->sign != yPtr->sign ) neg256M( &xPtr->sig ); + xPtr->sign = yPtr->sign; + add256M( &xPtr->sig, &yPtr->sig ); + } else { + sigY = yPtr->sig; + if ( 248 < expDiff ) { + sigY.v192 = 0; + sigY.v128 = 0; + sigY.v64 = 0; + sigY.v0 = 1; + } else { + while ( 0 < expDiff ) { + --expDiff; + shiftRight1Jam256M( &sigY ); + } + } + if ( xPtr->sign != yPtr->sign ) neg256M( &sigY ); + add256M( &xPtr->sig, &sigY ); + } + if ( xPtr->sig.v192 & UINT64_C( 0x8000000000000000 ) ) { + xPtr->sign = !xPtr->sign; + neg256M( &xPtr->sig ); + } + return; + copyY: + *xPtr = *yPtr; + +} + +static +void floatX256Mul( struct floatX256 *xPtr, const struct floatX256 *yPtr ) +{ + struct uint256 sig; + int bitNum; + + if ( xPtr->isNaN ) return; + if ( yPtr->isNaN ) { + xPtr->isNaN = true; + xPtr->isInf = false; + xPtr->isZero = false; + xPtr->sign = yPtr->sign; + return; + } + if ( yPtr->sign ) xPtr->sign = !xPtr->sign; + if ( xPtr->isInf ) { + if ( yPtr->isZero ) floatX256Invalid( xPtr ); + return; + } + if ( yPtr->isInf ) { + if ( xPtr->isZero ) { + floatX256Invalid( xPtr ); + return; + } + xPtr->isInf = true; + return; + } + if ( xPtr->isZero || yPtr->isZero ) { + if ( xPtr->sign ) { + *xPtr = floatX256NegativeZero; + } else { + *xPtr = floatX256PositiveZero; + } + return; + } + xPtr->exp += yPtr->exp; + sig.v192 = 0; + sig.v128 = 0; + sig.v64 = 0; + sig.v0 = 0; + for ( bitNum = 0; bitNum < 248; ++bitNum ) { + shiftRight1Jam256M( &sig ); + if ( xPtr->sig.v0 & 1 ) add256M( &sig, &yPtr->sig ); + shiftRight1256M( &xPtr->sig ); + } + if ( UINT64_C( 0x0100000000000000 ) <= sig.v192 ) { + ++xPtr->exp; + shiftRight1Jam256M( &sig ); + } + xPtr->sig = sig; + +} + +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +#ifdef FLOAT16 + +float16_t slow_ui32_to_f16( uint32_t a ) +{ + struct floatX x; + + ui32ToFloatX( a, &x ); + return floatXToF16( &x ); + +} + +#endif + +float32_t slow_ui32_to_f32( uint32_t a ) +{ + struct floatX x; + + ui32ToFloatX( a, &x ); + return floatXToF32( &x ); + +} + +#ifdef FLOAT64 + +float64_t slow_ui32_to_f64( uint32_t a ) +{ + struct floatX x; + + ui32ToFloatX( a, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef EXTFLOAT80 + +void slow_ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr ) +{ + struct floatX x; + + ui32ToFloatX( a, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_ui32_to_f128M( uint32_t a, float128_t *zPtr ) +{ + struct floatX x; + + ui32ToFloatX( a, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT16 + +float16_t slow_ui64_to_f16( uint64_t a ) +{ + struct floatX x; + + ui64ToFloatX( a, &x ); + return floatXToF16( &x ); + +} + +#endif + +float32_t slow_ui64_to_f32( uint64_t a ) +{ + struct floatX x; + + ui64ToFloatX( a, &x ); + return floatXToF32( &x ); + +} + +#ifdef FLOAT64 + +float64_t slow_ui64_to_f64( uint64_t a ) +{ + struct floatX x; + + ui64ToFloatX( a, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef EXTFLOAT80 + +void slow_ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr ) +{ + struct floatX x; + + ui64ToFloatX( a, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_ui64_to_f128M( uint64_t a, float128_t *zPtr ) +{ + struct floatX x; + + ui64ToFloatX( a, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT16 + +float16_t slow_i32_to_f16( int32_t a ) +{ + struct floatX x; + + i32ToFloatX( a, &x ); + return floatXToF16( &x ); + +} + +#endif + +float32_t slow_i32_to_f32( int32_t a ) +{ + struct floatX x; + + i32ToFloatX( a, &x ); + return floatXToF32( &x ); + +} + +#ifdef FLOAT64 + +float64_t slow_i32_to_f64( int32_t a ) +{ + struct floatX x; + + i32ToFloatX( a, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef EXTFLOAT80 + +void slow_i32_to_extF80M( int32_t a, extFloat80_t *zPtr ) +{ + struct floatX x; + + i32ToFloatX( a, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_i32_to_f128M( int32_t a, float128_t *zPtr ) +{ + struct floatX x; + + i32ToFloatX( a, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT16 + +float16_t slow_i64_to_f16( int64_t a ) +{ + struct floatX x; + + i64ToFloatX( a, &x ); + return floatXToF16( &x ); + +} + +#endif + +float32_t slow_i64_to_f32( int64_t a ) +{ + struct floatX x; + + i64ToFloatX( a, &x ); + return floatXToF32( &x ); + +} + +#ifdef FLOAT64 + +float64_t slow_i64_to_f64( int64_t a ) +{ + struct floatX x; + + i64ToFloatX( a, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef EXTFLOAT80 + +void slow_i64_to_extF80M( int64_t a, extFloat80_t *zPtr ) +{ + struct floatX x; + + i64ToFloatX( a, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_i64_to_f128M( int64_t a, float128_t *zPtr ) +{ + struct floatX x; + + i64ToFloatX( a, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT16 + +uint_fast32_t + slow_f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToUI32( &x, roundingMode, exact ); + +} + +uint_fast64_t + slow_f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToUI64( &x, roundingMode, exact ); + +} + +int_fast32_t + slow_f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToI32( &x, roundingMode, exact ); + +} + +int_fast64_t + slow_f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToI64( &x, roundingMode, exact ); + +} + +uint_fast32_t slow_f16_to_ui32_r_minMag( float16_t a, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToUI32( &x, softfloat_round_minMag, exact ); + +} + +uint_fast64_t slow_f16_to_ui64_r_minMag( float16_t a, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToUI64( &x, softfloat_round_minMag, exact ); + +} + +int_fast32_t slow_f16_to_i32_r_minMag( float16_t a, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToI32( &x, softfloat_round_minMag, exact ); + +} + +int_fast64_t slow_f16_to_i64_r_minMag( float16_t a, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToI64( &x, softfloat_round_minMag, exact ); + +} + +float32_t slow_f16_to_f32( float16_t a ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToF32( &x ); + +} + +#ifdef FLOAT64 + +float64_t slow_f16_to_f64( float16_t a ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef EXTFLOAT80 + +void slow_f16_to_extF80M( float16_t a, extFloat80_t *zPtr ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_f16_to_f128M( float16_t a, float128_t *zPtr ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +float16_t + slow_f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + floatXRoundToInt( &x, roundingMode, exact ); + return floatXToF16( &x ); + +} + +float16_t slow_f16_add( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + floatXAdd( &x, &y ); + return floatXToF16( &x ); + +} + +float16_t slow_f16_sub( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + y.sign = !y.sign; + floatXAdd( &x, &y ); + return floatXToF16( &x ); + + +} + +float16_t slow_f16_mul( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + floatXMul( &x, &y ); + return floatXToF16( &x ); + +} + +float16_t slow_f16_mulAdd( float16_t a, float16_t b, float16_t c ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + floatXMul( &x, &y ); + f16ToFloatX( c, &y ); + floatXAdd( &x, &y ); + return floatXToF16( &x ); + +} + +float16_t slow_f16_div( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + floatXDiv( &x, &y ); + return floatXToF16( &x ); + +} + +float16_t slow_f16_rem( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + floatXRem( &x, &y ); + return floatXToF16( &x ); + +} + +float16_t slow_f16_sqrt( float16_t a ) +{ + struct floatX x; + + f16ToFloatX( a, &x ); + floatXSqrt( &x ); + return floatXToF16( &x ); + +} + +bool slow_f16_eq( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + return floatXEq( &x, &y ); + +} + +bool slow_f16_le( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLe( &x, &y ); + +} + +bool slow_f16_lt( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLt( &x, &y ); + +} + +bool slow_f16_eq_signaling( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXEq( &x, &y ); + +} + +bool slow_f16_le_quiet( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + return floatXLe( &x, &y ); + +} + +bool slow_f16_lt_quiet( float16_t a, float16_t b ) +{ + struct floatX x, y; + + f16ToFloatX( a, &x ); + f16ToFloatX( b, &y ); + return floatXLt( &x, &y ); + +} + +#endif + +uint_fast32_t + slow_f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToUI32( &x, roundingMode, exact ); + +} + +uint_fast64_t + slow_f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToUI64( &x, roundingMode, exact ); + +} + +int_fast32_t + slow_f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToI32( &x, roundingMode, exact ); + +} + +int_fast64_t + slow_f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToI64( &x, roundingMode, exact ); + +} + +uint_fast32_t slow_f32_to_ui32_r_minMag( float32_t a, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToUI32( &x, softfloat_round_minMag, exact ); + +} + +uint_fast64_t slow_f32_to_ui64_r_minMag( float32_t a, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToUI64( &x, softfloat_round_minMag, exact ); + +} + +int_fast32_t slow_f32_to_i32_r_minMag( float32_t a, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToI32( &x, softfloat_round_minMag, exact ); + +} + +int_fast64_t slow_f32_to_i64_r_minMag( float32_t a, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToI64( &x, softfloat_round_minMag, exact ); + +} + +#ifdef FLOAT16 + +float16_t slow_f32_to_f16( float32_t a ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToF16( &x ); + +} + +#endif + +#ifdef FLOAT64 + +float64_t slow_f32_to_f64( float32_t a ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef EXTFLOAT80 + +void slow_f32_to_extF80M( float32_t a, extFloat80_t *zPtr ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_f32_to_f128M( float32_t a, float128_t *zPtr ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +float32_t + slow_f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + floatXRoundToInt( &x, roundingMode, exact ); + return floatXToF32( &x ); + +} + +float32_t slow_f32_add( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + floatXAdd( &x, &y ); + return floatXToF32( &x ); + +} + +float32_t slow_f32_sub( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + y.sign = !y.sign; + floatXAdd( &x, &y ); + return floatXToF32( &x ); + + +} + +float32_t slow_f32_mul( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + floatXMul( &x, &y ); + return floatXToF32( &x ); + +} + +float32_t slow_f32_mulAdd( float32_t a, float32_t b, float32_t c ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + floatXMul( &x, &y ); + f32ToFloatX( c, &y ); + floatXAdd( &x, &y ); + return floatXToF32( &x ); + +} + +float32_t slow_f32_div( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + floatXDiv( &x, &y ); + return floatXToF32( &x ); + +} + +float32_t slow_f32_rem( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + floatXRem( &x, &y ); + return floatXToF32( &x ); + +} + +float32_t slow_f32_sqrt( float32_t a ) +{ + struct floatX x; + + f32ToFloatX( a, &x ); + floatXSqrt( &x ); + return floatXToF32( &x ); + +} + +bool slow_f32_eq( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + return floatXEq( &x, &y ); + +} + +bool slow_f32_le( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLe( &x, &y ); + +} + +bool slow_f32_lt( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLt( &x, &y ); + +} + +bool slow_f32_eq_signaling( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXEq( &x, &y ); + +} + +bool slow_f32_le_quiet( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + return floatXLe( &x, &y ); + +} + +bool slow_f32_lt_quiet( float32_t a, float32_t b ) +{ + struct floatX x, y; + + f32ToFloatX( a, &x ); + f32ToFloatX( b, &y ); + return floatXLt( &x, &y ); + +} + +#ifdef FLOAT64 + +uint_fast32_t + slow_f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToUI32( &x, roundingMode, exact ); + +} + +uint_fast64_t + slow_f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToUI64( &x, roundingMode, exact ); + +} + +int_fast32_t + slow_f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToI32( &x, roundingMode, exact ); + +} + +int_fast64_t + slow_f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToI64( &x, roundingMode, exact ); + +} + +uint_fast32_t slow_f64_to_ui32_r_minMag( float64_t a, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToUI32( &x, softfloat_round_minMag, exact ); + +} + +uint_fast64_t slow_f64_to_ui64_r_minMag( float64_t a, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToUI64( &x, softfloat_round_minMag, exact ); + +} + +int_fast32_t slow_f64_to_i32_r_minMag( float64_t a, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToI32( &x, softfloat_round_minMag, exact ); + +} + +int_fast64_t slow_f64_to_i64_r_minMag( float64_t a, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToI64( &x, softfloat_round_minMag, exact ); + +} + +#ifdef FLOAT16 + +float16_t slow_f64_to_f16( float64_t a ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToF16( &x ); + +} + +#endif + +float32_t slow_f64_to_f32( float64_t a ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + return floatXToF32( &x ); + +} + +#ifdef EXTFLOAT80 + +void slow_f64_to_extF80M( float64_t a, extFloat80_t *zPtr ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_f64_to_f128M( float64_t a, float128_t *zPtr ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +float64_t + slow_f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + floatXRoundToInt( &x, roundingMode, exact ); + return floatXToF64( &x ); + +} + +float64_t slow_f64_add( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + floatXAdd( &x, &y ); + return floatXToF64( &x ); + +} + +float64_t slow_f64_sub( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + y.sign = !y.sign; + floatXAdd( &x, &y ); + return floatXToF64( &x ); + +} + +float64_t slow_f64_mul( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + floatXMul( &x, &y ); + return floatXToF64( &x ); + +} + +float64_t slow_f64_mulAdd( float64_t a, float64_t b, float64_t c ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + floatXMul( &x, &y ); + f64ToFloatX( c, &y ); + floatXAdd( &x, &y ); + return floatXToF64( &x ); + +} + +float64_t slow_f64_div( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + floatXDiv( &x, &y ); + return floatXToF64( &x ); + +} + +float64_t slow_f64_rem( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + floatXRem( &x, &y ); + return floatXToF64( &x ); + +} + +float64_t slow_f64_sqrt( float64_t a ) +{ + struct floatX x; + + f64ToFloatX( a, &x ); + floatXSqrt( &x ); + return floatXToF64( &x ); + +} + +bool slow_f64_eq( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + return floatXEq( &x, &y ); + +} + +bool slow_f64_le( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLe( &x, &y ); + +} + +bool slow_f64_lt( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLt( &x, &y ); + +} + +bool slow_f64_eq_signaling( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXEq( &x, &y ); + +} + +bool slow_f64_le_quiet( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + return floatXLe( &x, &y ); + +} + +bool slow_f64_lt_quiet( float64_t a, float64_t b ) +{ + struct floatX x, y; + + f64ToFloatX( a, &x ); + f64ToFloatX( b, &y ); + return floatXLt( &x, &y ); + +} + +#endif + +#ifdef EXTFLOAT80 + +uint_fast32_t + slow_extF80M_to_ui32( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToUI32( &x, roundingMode, exact ); + +} + +uint_fast64_t + slow_extF80M_to_ui64( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToUI64( &x, roundingMode, exact ); + +} + +int_fast32_t + slow_extF80M_to_i32( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToI32( &x, roundingMode, exact ); + +} + +int_fast64_t + slow_extF80M_to_i64( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToI64( &x, roundingMode, exact ); + +} + +uint_fast32_t + slow_extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToUI32( &x, softfloat_round_minMag, exact ); + +} + +uint_fast64_t + slow_extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToUI64( &x, softfloat_round_minMag, exact ); + +} + +int_fast32_t + slow_extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToI32( &x, softfloat_round_minMag, exact ); + +} + +int_fast64_t + slow_extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToI64( &x, softfloat_round_minMag, exact ); + +} + +#ifdef FLOAT16 + +float16_t slow_extF80M_to_f16( const extFloat80_t *aPtr ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToF16( &x ); + +} + +#endif + +float32_t slow_extF80M_to_f32( const extFloat80_t *aPtr ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToF32( &x ); + +} + +#ifdef FLOAT64 + +float64_t slow_extF80M_to_f64( const extFloat80_t *aPtr ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef FLOAT128 + +void slow_extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + floatXToF128M( &x, zPtr ); + +} + +#endif + +void + slow_extF80M_roundToInt( + const extFloat80_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + extFloat80_t *zPtr + ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + floatXRoundToInt( &x, roundingMode, exact ); + floatXToExtF80M( &x, zPtr ); + +} + +void + slow_extF80M_add( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + floatXAdd( &x, &y ); + floatXToExtF80M( &x, zPtr ); + +} + +void + slow_extF80M_sub( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + y.sign = !y.sign; + floatXAdd( &x, &y ); + floatXToExtF80M( &x, zPtr ); + +} + +void + slow_extF80M_mul( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + floatXMul( &x, &y ); + floatXToExtF80M( &x, zPtr ); + +} + +void + slow_extF80M_div( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + floatXDiv( &x, &y ); + floatXToExtF80M( &x, zPtr ); + +} + +void + slow_extF80M_rem( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + floatXRem( &x, &y ); + floatXToExtF80M( &x, zPtr ); + +} + +void slow_extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr ) +{ + struct floatX x; + + extF80MToFloatX( aPtr, &x ); + floatXSqrt( &x ); + floatXToExtF80M( &x, zPtr ); + +} + +bool slow_extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + return floatXEq( &x, &y ); + +} + +bool slow_extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLe( &x, &y ); + +} + +bool slow_extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLt( &x, &y ); + +} + +bool + slow_extF80M_eq_signaling( + const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXEq( &x, &y ); + +} + +bool slow_extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + return floatXLe( &x, &y ); + +} + +bool slow_extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + struct floatX x, y; + + extF80MToFloatX( aPtr, &x ); + extF80MToFloatX( bPtr, &y ); + return floatXLt( &x, &y ); + +} + +#endif + +#ifdef FLOAT128 + +uint_fast32_t + slow_f128M_to_ui32( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToUI32( &x, roundingMode, exact ); + +} + +uint_fast64_t + slow_f128M_to_ui64( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToUI64( &x, roundingMode, exact ); + +} + +int_fast32_t + slow_f128M_to_i32( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToI32( &x, roundingMode, exact ); + +} + +int_fast64_t + slow_f128M_to_i64( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToI64( &x, roundingMode, exact ); + +} + +uint_fast32_t slow_f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToUI32( &x, softfloat_round_minMag, exact ); + +} + +uint_fast64_t slow_f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToUI64( &x, softfloat_round_minMag, exact ); + +} + +int_fast32_t slow_f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToI32( &x, softfloat_round_minMag, exact ); + +} + +int_fast64_t slow_f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToI64( &x, softfloat_round_minMag, exact ); + +} + +#ifdef FLOAT16 + +float16_t slow_f128M_to_f16( const float128_t *aPtr ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToF16( &x ); + +} + +#endif + +float32_t slow_f128M_to_f32( const float128_t *aPtr ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToF32( &x ); + +} + +#ifdef FLOAT64 + +float64_t slow_f128M_to_f64( const float128_t *aPtr ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + return floatXToF64( &x ); + +} + +#endif + +#ifdef EXTFLOAT80 + +void slow_f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + floatXToExtF80M( &x, zPtr ); + +} + +#endif + +void + slow_f128M_roundToInt( + const float128_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + float128_t *zPtr + ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + floatXRoundToInt( &x, roundingMode, exact ); + floatXToF128M( &x, zPtr ); + +} + +void + slow_f128M_add( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + floatXAdd( &x, &y ); + floatXToF128M( &x, zPtr ); + +} + +void + slow_f128M_sub( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + y.sign = !y.sign; + floatXAdd( &x, &y ); + floatXToF128M( &x, zPtr ); + +} + +void + slow_f128M_mul( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + floatXMul( &x, &y ); + floatXToF128M( &x, zPtr ); + +} + +void + slow_f128M_mulAdd( + const float128_t *aPtr, + const float128_t *bPtr, + const float128_t *cPtr, + float128_t *zPtr + ) +{ + struct floatX256 x, y; + + f128MToFloatX256( aPtr, &x ); + f128MToFloatX256( bPtr, &y ); + floatX256Mul( &x, &y ); + f128MToFloatX256( cPtr, &y ); + floatX256Add( &x, &y ); + floatX256ToF128M( &x, zPtr ); + +} + +void + slow_f128M_div( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + floatXDiv( &x, &y ); + floatXToF128M( &x, zPtr ); + +} + +void + slow_f128M_rem( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + floatXRem( &x, &y ); + floatXToF128M( &x, zPtr ); + +} + +void slow_f128M_sqrt( const float128_t *aPtr, float128_t *zPtr ) +{ + struct floatX x; + + f128MToFloatX( aPtr, &x ); + floatXSqrt( &x ); + floatXToF128M( &x, zPtr ); + +} + +bool slow_f128M_eq( const float128_t *aPtr, const float128_t *bPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + return floatXEq( &x, &y ); + +} + +bool slow_f128M_le( const float128_t *aPtr, const float128_t *bPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLe( &x, &y ); + +} + +bool slow_f128M_lt( const float128_t *aPtr, const float128_t *bPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXLt( &x, &y ); + +} + +bool slow_f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + if ( x.isNaN || y.isNaN ) { + slowfloat_exceptionFlags |= softfloat_flag_invalid; + } + return floatXEq( &x, &y ); + +} + +bool slow_f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + return floatXLe( &x, &y ); + +} + +bool slow_f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr ) +{ + struct floatX x, y; + + f128MToFloatX( aPtr, &x ); + f128MToFloatX( bPtr, &y ); + return floatXLt( &x, &y ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.h new file mode 100644 index 000000000..7af1d1eb5 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/slowfloat.h @@ -0,0 +1,298 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "softfloat.h" + +extern uint_fast8_t slowfloat_roundingMode; +extern uint_fast8_t slowfloat_detectTininess; +extern uint_fast8_t slowfloat_exceptionFlags; +#ifdef EXTFLOAT80 +extern uint_fast8_t slow_extF80_roundingPrecision; +#endif + +#ifdef FLOAT16 +float16_t slow_ui32_to_f16( uint32_t ); +#endif +float32_t slow_ui32_to_f32( uint32_t ); +#ifdef FLOAT64 +float64_t slow_ui32_to_f64( uint32_t ); +#endif +#ifdef EXTFLOAT80 +void slow_ui32_to_extF80M( uint32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_ui32_to_f128M( uint32_t, float128_t * ); +#endif +#ifdef FLOAT16 +float16_t slow_ui64_to_f16( uint64_t ); +#endif +float32_t slow_ui64_to_f32( uint64_t ); +#ifdef FLOAT64 +float64_t slow_ui64_to_f64( uint64_t ); +#endif +#ifdef EXTFLOAT80 +void slow_ui64_to_extF80M( uint64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_ui64_to_f128M( uint64_t, float128_t * ); +#endif +#ifdef FLOAT16 +float16_t slow_i32_to_f16( int32_t ); +#endif +float32_t slow_i32_to_f32( int32_t ); +#ifdef FLOAT64 +float64_t slow_i32_to_f64( int32_t ); +#endif +#ifdef EXTFLOAT80 +void slow_i32_to_extF80M( int32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_i32_to_f128M( int32_t, float128_t * ); +#endif +#ifdef FLOAT16 +float16_t slow_i64_to_f16( int64_t ); +#endif +float32_t slow_i64_to_f32( int64_t ); +#ifdef FLOAT64 +float64_t slow_i64_to_f64( int64_t ); +#endif +#ifdef EXTFLOAT80 +void slow_i64_to_extF80M( int64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_i64_to_f128M( int64_t, float128_t * ); +#endif + +#ifdef FLOAT16 +uint_fast32_t slow_f16_to_ui32( float16_t, uint_fast8_t, bool ); +uint_fast64_t slow_f16_to_ui64( float16_t, uint_fast8_t, bool ); +int_fast32_t slow_f16_to_i32( float16_t, uint_fast8_t, bool ); +int_fast64_t slow_f16_to_i64( float16_t, uint_fast8_t, bool ); +uint_fast32_t slow_f16_to_ui32_r_minMag( float16_t, bool ); +uint_fast64_t slow_f16_to_ui64_r_minMag( float16_t, bool ); +int_fast32_t slow_f16_to_i32_r_minMag( float16_t, bool ); +int_fast64_t slow_f16_to_i64_r_minMag( float16_t, bool ); +float32_t slow_f16_to_f32( float16_t ); +#ifdef FLOAT64 +float64_t slow_f16_to_f64( float16_t ); +#endif +#ifdef EXTFLOAT80 +void slow_f16_to_extF80M( float16_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_f16_to_f128M( float16_t, float128_t * ); +#endif +float16_t slow_f16_roundToInt( float16_t, uint_fast8_t, bool ); +float16_t slow_f16_add( float16_t, float16_t ); +float16_t slow_f16_sub( float16_t, float16_t ); +float16_t slow_f16_mul( float16_t, float16_t ); +float16_t slow_f16_mulAdd( float16_t, float16_t, float16_t ); +float16_t slow_f16_div( float16_t, float16_t ); +float16_t slow_f16_rem( float16_t, float16_t ); +float16_t slow_f16_sqrt( float16_t ); +bool slow_f16_eq( float16_t, float16_t ); +bool slow_f16_le( float16_t, float16_t ); +bool slow_f16_lt( float16_t, float16_t ); +bool slow_f16_eq_signaling( float16_t, float16_t ); +bool slow_f16_le_quiet( float16_t, float16_t ); +bool slow_f16_lt_quiet( float16_t, float16_t ); +#endif + +uint_fast32_t slow_f32_to_ui32( float32_t, uint_fast8_t, bool ); +uint_fast64_t slow_f32_to_ui64( float32_t, uint_fast8_t, bool ); +int_fast32_t slow_f32_to_i32( float32_t, uint_fast8_t, bool ); +int_fast64_t slow_f32_to_i64( float32_t, uint_fast8_t, bool ); +uint_fast32_t slow_f32_to_ui32_r_minMag( float32_t, bool ); +uint_fast64_t slow_f32_to_ui64_r_minMag( float32_t, bool ); +int_fast32_t slow_f32_to_i32_r_minMag( float32_t, bool ); +int_fast64_t slow_f32_to_i64_r_minMag( float32_t, bool ); +#ifdef FLOAT16 +float16_t slow_f32_to_f16( float32_t ); +#endif +#ifdef FLOAT64 +float64_t slow_f32_to_f64( float32_t ); +#endif +#ifdef EXTFLOAT80 +void slow_f32_to_extF80M( float32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_f32_to_f128M( float32_t, float128_t * ); +#endif +float32_t slow_f32_roundToInt( float32_t, uint_fast8_t, bool ); +float32_t slow_f32_add( float32_t, float32_t ); +float32_t slow_f32_sub( float32_t, float32_t ); +float32_t slow_f32_mul( float32_t, float32_t ); +float32_t slow_f32_mulAdd( float32_t, float32_t, float32_t ); +float32_t slow_f32_div( float32_t, float32_t ); +float32_t slow_f32_rem( float32_t, float32_t ); +float32_t slow_f32_sqrt( float32_t ); +bool slow_f32_eq( float32_t, float32_t ); +bool slow_f32_le( float32_t, float32_t ); +bool slow_f32_lt( float32_t, float32_t ); +bool slow_f32_eq_signaling( float32_t, float32_t ); +bool slow_f32_le_quiet( float32_t, float32_t ); +bool slow_f32_lt_quiet( float32_t, float32_t ); + +#ifdef FLOAT64 +uint_fast32_t slow_f64_to_ui32( float64_t, uint_fast8_t, bool ); +uint_fast64_t slow_f64_to_ui64( float64_t, uint_fast8_t, bool ); +int_fast32_t slow_f64_to_i32( float64_t, uint_fast8_t, bool ); +int_fast64_t slow_f64_to_i64( float64_t, uint_fast8_t, bool ); +uint_fast32_t slow_f64_to_ui32_r_minMag( float64_t, bool ); +uint_fast64_t slow_f64_to_ui64_r_minMag( float64_t, bool ); +int_fast32_t slow_f64_to_i32_r_minMag( float64_t, bool ); +int_fast64_t slow_f64_to_i64_r_minMag( float64_t, bool ); +#ifdef FLOAT16 +float16_t slow_f64_to_f16( float64_t ); +#endif +float32_t slow_f64_to_f32( float64_t ); +#ifdef EXTFLOAT80 +void slow_f64_to_extF80M( float64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_f64_to_f128M( float64_t, float128_t * ); +#endif +float64_t slow_f64_roundToInt( float64_t, uint_fast8_t, bool ); +float64_t slow_f64_add( float64_t, float64_t ); +float64_t slow_f64_sub( float64_t, float64_t ); +float64_t slow_f64_mul( float64_t, float64_t ); +float64_t slow_f64_mulAdd( float64_t, float64_t, float64_t ); +float64_t slow_f64_div( float64_t, float64_t ); +float64_t slow_f64_rem( float64_t, float64_t ); +float64_t slow_f64_sqrt( float64_t ); +bool slow_f64_eq( float64_t, float64_t ); +bool slow_f64_le( float64_t, float64_t ); +bool slow_f64_lt( float64_t, float64_t ); +bool slow_f64_eq_signaling( float64_t, float64_t ); +bool slow_f64_le_quiet( float64_t, float64_t ); +bool slow_f64_lt_quiet( float64_t, float64_t ); +#endif + +#ifdef EXTFLOAT80 +uint_fast32_t slow_extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool ); +uint_fast64_t slow_extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool ); +int_fast32_t slow_extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool ); +int_fast64_t slow_extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool ); +uint_fast32_t slow_extF80M_to_ui32_r_minMag( const extFloat80_t *, bool ); +uint_fast64_t slow_extF80M_to_ui64_r_minMag( const extFloat80_t *, bool ); +int_fast32_t slow_extF80M_to_i32_r_minMag( const extFloat80_t *, bool ); +int_fast64_t slow_extF80M_to_i64_r_minMag( const extFloat80_t *, bool ); +#ifdef FLOAT16 +float16_t slow_extF80M_to_f16( const extFloat80_t * ); +#endif +float32_t slow_extF80M_to_f32( const extFloat80_t * ); +#ifdef FLOAT64 +float64_t slow_extF80M_to_f64( const extFloat80_t * ); +#endif +#ifdef FLOAT128 +void slow_extF80M_to_f128M( const extFloat80_t *, float128_t * ); +#endif +void + slow_extF80M_roundToInt( + const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ); +void + slow_extF80M_add( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + slow_extF80M_sub( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + slow_extF80M_mul( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + slow_extF80M_mulAdd( + const extFloat80_t *, + const extFloat80_t *, + const extFloat80_t *, + extFloat80_t * + ); +void + slow_extF80M_div( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + slow_extF80M_rem( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void slow_extF80M_sqrt( const extFloat80_t *, extFloat80_t * ); +bool slow_extF80M_eq( const extFloat80_t *, const extFloat80_t * ); +bool slow_extF80M_le( const extFloat80_t *, const extFloat80_t * ); +bool slow_extF80M_lt( const extFloat80_t *, const extFloat80_t * ); +bool slow_extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * ); +bool slow_extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * ); +bool slow_extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * ); +#endif + +#ifdef FLOAT128 +uint_fast32_t slow_f128M_to_ui32( const float128_t *, uint_fast8_t, bool ); +uint_fast64_t slow_f128M_to_ui64( const float128_t *, uint_fast8_t, bool ); +int_fast32_t slow_f128M_to_i32( const float128_t *, uint_fast8_t, bool ); +int_fast64_t slow_f128M_to_i64( const float128_t *, uint_fast8_t, bool ); +uint_fast32_t slow_f128M_to_ui32_r_minMag( const float128_t *, bool ); +uint_fast64_t slow_f128M_to_ui64_r_minMag( const float128_t *, bool ); +int_fast32_t slow_f128M_to_i32_r_minMag( const float128_t *, bool ); +int_fast64_t slow_f128M_to_i64_r_minMag( const float128_t *, bool ); +#ifdef FLOAT16 +float16_t slow_f128M_to_f16( const float128_t * ); +#endif +float32_t slow_f128M_to_f32( const float128_t * ); +#ifdef FLOAT64 +float64_t slow_f128M_to_f64( const float128_t * ); +#endif +#ifdef EXTFLOAT80 +void slow_f128M_to_extF80M( const float128_t *, extFloat80_t * ); +#endif +void + slow_f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * ); +void slow_f128M_add( const float128_t *, const float128_t *, float128_t * ); +void slow_f128M_sub( const float128_t *, const float128_t *, float128_t * ); +void slow_f128M_mul( const float128_t *, const float128_t *, float128_t * ); +void + slow_f128M_mulAdd( + const float128_t *, const float128_t *, const float128_t *, float128_t * + ); +void slow_f128M_div( const float128_t *, const float128_t *, float128_t * ); +void slow_f128M_rem( const float128_t *, const float128_t *, float128_t * ); +void slow_f128M_sqrt( const float128_t *, float128_t * ); +bool slow_f128M_eq( const float128_t *, const float128_t * ); +bool slow_f128M_le( const float128_t *, const float128_t * ); +bool slow_f128M_lt( const float128_t *, const float128_t * ); +bool slow_f128M_eq_signaling( const float128_t *, const float128_t * ); +bool slow_f128M_le_quiet( const float128_t *, const float128_t * ); +bool slow_f128M_lt_quiet( const float128_t *, const float128_t * ); +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/standardFunctionInfos.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/standardFunctionInfos.c new file mode 100644 index 000000000..fa6a61dc5 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/standardFunctionInfos.c @@ -0,0 +1,471 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "functions.h" + +#define RNEVEN ROUND_NEAR_EVEN +#define RMINM ROUND_MINMAG +#define RMIN ROUND_MIN +#define RMAX ROUND_MAX +#define RNMAXM ROUND_NEAR_MAXMAG + +const struct standardFunctionInfo standardFunctionInfos[] = { + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 + { "ui32_to_f16", UI32_TO_F16, 0, 0 }, +#endif + { "ui32_to_f32", UI32_TO_F32, 0, 0 }, +#ifdef FLOAT64 + { "ui32_to_f64", UI32_TO_F64, 0, 0 }, +#endif +#ifdef EXTFLOAT80 + { "ui32_to_extF80", UI32_TO_EXTF80, 0, 0 }, +#endif +#ifdef FLOAT128 + { "ui32_to_f128", UI32_TO_F128, 0, 0 }, +#endif +#ifdef FLOAT16 + { "ui64_to_f16", UI64_TO_F16, 0, 0 }, +#endif + { "ui64_to_f32", UI64_TO_F32, 0, 0 }, +#ifdef FLOAT64 + { "ui64_to_f64", UI64_TO_F64, 0, 0 }, +#endif +#ifdef EXTFLOAT80 + { "ui64_to_extF80", UI64_TO_EXTF80, 0, 0 }, +#endif +#ifdef FLOAT128 + { "ui64_to_f128", UI64_TO_F128, 0, 0 }, +#endif +#ifdef FLOAT16 + { "i32_to_f16", I32_TO_F16, 0, 0 }, +#endif + { "i32_to_f32", I32_TO_F32, 0, 0 }, +#ifdef FLOAT64 + { "i32_to_f64", I32_TO_F64, 0, 0 }, +#endif +#ifdef EXTFLOAT80 + { "i32_to_extF80", I32_TO_EXTF80, 0, 0 }, +#endif +#ifdef FLOAT128 + { "i32_to_f128", I32_TO_F128, 0, 0 }, +#endif +#ifdef FLOAT16 + { "i64_to_f16", I64_TO_F16, 0, 0 }, +#endif + { "i64_to_f32", I64_TO_F32, 0, 0 }, +#ifdef FLOAT64 + { "i64_to_f64", I64_TO_F64, 0, 0 }, +#endif +#ifdef EXTFLOAT80 + { "i64_to_extF80", I64_TO_EXTF80, 0, 0 }, +#endif +#ifdef FLOAT128 + { "i64_to_f128", I64_TO_F128, 0, 0 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 + { "f16_to_ui32_r_near_even", F16_TO_UI32, RNEVEN, false }, + { "f16_to_ui32_r_minMag", F16_TO_UI32, RMINM, false }, + { "f16_to_ui32_r_min", F16_TO_UI32, RMIN, false }, + { "f16_to_ui32_r_max", F16_TO_UI32, RMAX, false }, + { "f16_to_ui32_r_near_maxMag", F16_TO_UI32, RNMAXM, false }, + { "f16_to_ui64_r_near_even", F16_TO_UI64, RNEVEN, false }, + { "f16_to_ui64_r_minMag", F16_TO_UI64, RMINM, false }, + { "f16_to_ui64_r_min", F16_TO_UI64, RMIN, false }, + { "f16_to_ui64_r_max", F16_TO_UI64, RMAX, false }, + { "f16_to_ui64_r_near_maxMag", F16_TO_UI64, RNMAXM, false }, + { "f16_to_i32_r_near_even", F16_TO_I32, RNEVEN, false }, + { "f16_to_i32_r_minMag", F16_TO_I32, RMINM, false }, + { "f16_to_i32_r_min", F16_TO_I32, RMIN, false }, + { "f16_to_i32_r_max", F16_TO_I32, RMAX, false }, + { "f16_to_i32_r_near_maxMag", F16_TO_I32, RNMAXM, false }, + { "f16_to_i64_r_near_even", F16_TO_I64, RNEVEN, false }, + { "f16_to_i64_r_minMag", F16_TO_I64, RMINM, false }, + { "f16_to_i64_r_min", F16_TO_I64, RMIN, false }, + { "f16_to_i64_r_max", F16_TO_I64, RMAX, false }, + { "f16_to_i64_r_near_maxMag", F16_TO_I64, RNMAXM, false }, + { "f16_to_ui32_rx_near_even", F16_TO_UI32, RNEVEN, true }, + { "f16_to_ui32_rx_minMag", F16_TO_UI32, RMINM, true }, + { "f16_to_ui32_rx_min", F16_TO_UI32, RMIN, true }, + { "f16_to_ui32_rx_max", F16_TO_UI32, RMAX, true }, + { "f16_to_ui32_rx_near_maxMag", F16_TO_UI32, RNMAXM, true }, + { "f16_to_ui64_rx_near_even", F16_TO_UI64, RNEVEN, true }, + { "f16_to_ui64_rx_minMag", F16_TO_UI64, RMINM, true }, + { "f16_to_ui64_rx_min", F16_TO_UI64, RMIN, true }, + { "f16_to_ui64_rx_max", F16_TO_UI64, RMAX, true }, + { "f16_to_ui64_rx_near_maxMag", F16_TO_UI64, RNMAXM, true }, + { "f16_to_i32_rx_near_even", F16_TO_I32, RNEVEN, true }, + { "f16_to_i32_rx_minMag", F16_TO_I32, RMINM, true }, + { "f16_to_i32_rx_min", F16_TO_I32, RMIN, true }, + { "f16_to_i32_rx_max", F16_TO_I32, RMAX, true }, + { "f16_to_i32_rx_near_maxMag", F16_TO_I32, RNMAXM, true }, + { "f16_to_i64_rx_near_even", F16_TO_I64, RNEVEN, true }, + { "f16_to_i64_rx_minMag", F16_TO_I64, RMINM, true }, + { "f16_to_i64_rx_min", F16_TO_I64, RMIN, true }, + { "f16_to_i64_rx_max", F16_TO_I64, RMAX, true }, + { "f16_to_i64_rx_near_maxMag", F16_TO_I64, RNMAXM, true }, + { "f16_to_f32", F16_TO_F32, 0, 0 }, +#ifdef FLOAT64 + { "f16_to_f64", F16_TO_F64, 0, 0 }, +#endif +#ifdef EXTFLOAT80 + { "f16_to_extF80", F16_TO_EXTF80, 0, 0 }, +#endif +#ifdef FLOAT128 + { "f16_to_f128", F16_TO_F128, 0, 0 }, +#endif + { "f16_roundToInt_r_near_even", F16_ROUNDTOINT, RNEVEN, false }, + { "f16_roundToInt_r_minMag", F16_ROUNDTOINT, RMINM, false }, + { "f16_roundToInt_r_min", F16_ROUNDTOINT, RMIN, false }, + { "f16_roundToInt_r_max", F16_ROUNDTOINT, RMAX, false }, + { "f16_roundToInt_r_near_maxMag", F16_ROUNDTOINT, RNMAXM, false }, + { "f16_roundToInt_x", F16_ROUNDTOINT, 0, true }, + { "f16_add", F16_ADD, 0, 0 }, + { "f16_sub", F16_SUB, 0, 0 }, + { "f16_mul", F16_MUL, 0, 0 }, + { "f16_mulAdd", F16_MULADD, 0, 0 }, + { "f16_div", F16_DIV, 0, 0 }, + { "f16_rem", F16_REM, 0, 0 }, + { "f16_sqrt", F16_SQRT, 0, 0 }, + { "f16_eq", F16_EQ, 0, 0 }, + { "f16_le", F16_LE, 0, 0 }, + { "f16_lt", F16_LT, 0, 0 }, + { "f16_eq_signaling", F16_EQ_SIGNALING, 0, 0 }, + { "f16_le_quiet", F16_LE_QUIET, 0, 0 }, + { "f16_lt_quiet", F16_LT_QUIET, 0, 0 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + { "f32_to_ui32_r_near_even", F32_TO_UI32, RNEVEN, false }, + { "f32_to_ui32_r_minMag", F32_TO_UI32, RMINM, false }, + { "f32_to_ui32_r_min", F32_TO_UI32, RMIN, false }, + { "f32_to_ui32_r_max", F32_TO_UI32, RMAX, false }, + { "f32_to_ui32_r_near_maxMag", F32_TO_UI32, RNMAXM, false }, + { "f32_to_ui64_r_near_even", F32_TO_UI64, RNEVEN, false }, + { "f32_to_ui64_r_minMag", F32_TO_UI64, RMINM, false }, + { "f32_to_ui64_r_min", F32_TO_UI64, RMIN, false }, + { "f32_to_ui64_r_max", F32_TO_UI64, RMAX, false }, + { "f32_to_ui64_r_near_maxMag", F32_TO_UI64, RNMAXM, false }, + { "f32_to_i32_r_near_even", F32_TO_I32, RNEVEN, false }, + { "f32_to_i32_r_minMag", F32_TO_I32, RMINM, false }, + { "f32_to_i32_r_min", F32_TO_I32, RMIN, false }, + { "f32_to_i32_r_max", F32_TO_I32, RMAX, false }, + { "f32_to_i32_r_near_maxMag", F32_TO_I32, RNMAXM, false }, + { "f32_to_i64_r_near_even", F32_TO_I64, RNEVEN, false }, + { "f32_to_i64_r_minMag", F32_TO_I64, RMINM, false }, + { "f32_to_i64_r_min", F32_TO_I64, RMIN, false }, + { "f32_to_i64_r_max", F32_TO_I64, RMAX, false }, + { "f32_to_i64_r_near_maxMag", F32_TO_I64, RNMAXM, false }, + { "f32_to_ui32_rx_near_even", F32_TO_UI32, RNEVEN, true }, + { "f32_to_ui32_rx_minMag", F32_TO_UI32, RMINM, true }, + { "f32_to_ui32_rx_min", F32_TO_UI32, RMIN, true }, + { "f32_to_ui32_rx_max", F32_TO_UI32, RMAX, true }, + { "f32_to_ui32_rx_near_maxMag", F32_TO_UI32, RNMAXM, true }, + { "f32_to_ui64_rx_near_even", F32_TO_UI64, RNEVEN, true }, + { "f32_to_ui64_rx_minMag", F32_TO_UI64, RMINM, true }, + { "f32_to_ui64_rx_min", F32_TO_UI64, RMIN, true }, + { "f32_to_ui64_rx_max", F32_TO_UI64, RMAX, true }, + { "f32_to_ui64_rx_near_maxMag", F32_TO_UI64, RNMAXM, true }, + { "f32_to_i32_rx_near_even", F32_TO_I32, RNEVEN, true }, + { "f32_to_i32_rx_minMag", F32_TO_I32, RMINM, true }, + { "f32_to_i32_rx_min", F32_TO_I32, RMIN, true }, + { "f32_to_i32_rx_max", F32_TO_I32, RMAX, true }, + { "f32_to_i32_rx_near_maxMag", F32_TO_I32, RNMAXM, true }, + { "f32_to_i64_rx_near_even", F32_TO_I64, RNEVEN, true }, + { "f32_to_i64_rx_minMag", F32_TO_I64, RMINM, true }, + { "f32_to_i64_rx_min", F32_TO_I64, RMIN, true }, + { "f32_to_i64_rx_max", F32_TO_I64, RMAX, true }, + { "f32_to_i64_rx_near_maxMag", F32_TO_I64, RNMAXM, true }, +#ifdef FLOAT16 + { "f32_to_f16", F32_TO_F16, 0, 0 }, +#endif +#ifdef FLOAT64 + { "f32_to_f64", F32_TO_F64, 0, 0 }, +#endif +#ifdef EXTFLOAT80 + { "f32_to_extF80", F32_TO_EXTF80, 0, 0 }, +#endif +#ifdef FLOAT128 + { "f32_to_f128", F32_TO_F128, 0, 0 }, +#endif + { "f32_roundToInt_r_near_even", F32_ROUNDTOINT, RNEVEN, false }, + { "f32_roundToInt_r_minMag", F32_ROUNDTOINT, RMINM, false }, + { "f32_roundToInt_r_min", F32_ROUNDTOINT, RMIN, false }, + { "f32_roundToInt_r_max", F32_ROUNDTOINT, RMAX, false }, + { "f32_roundToInt_r_near_maxMag", F32_ROUNDTOINT, RNMAXM, false }, + { "f32_roundToInt_x", F32_ROUNDTOINT, 0, true }, + { "f32_add", F32_ADD, 0, 0 }, + { "f32_sub", F32_SUB, 0, 0 }, + { "f32_mul", F32_MUL, 0, 0 }, + { "f32_mulAdd", F32_MULADD, 0, 0 }, + { "f32_div", F32_DIV, 0, 0 }, + { "f32_rem", F32_REM, 0, 0 }, + { "f32_sqrt", F32_SQRT, 0, 0 }, + { "f32_eq", F32_EQ, 0, 0 }, + { "f32_le", F32_LE, 0, 0 }, + { "f32_lt", F32_LT, 0, 0 }, + { "f32_eq_signaling", F32_EQ_SIGNALING, 0, 0 }, + { "f32_le_quiet", F32_LE_QUIET, 0, 0 }, + { "f32_lt_quiet", F32_LT_QUIET, 0, 0 }, + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT64 + { "f64_to_ui32_r_near_even", F64_TO_UI32, RNEVEN, false }, + { "f64_to_ui32_r_minMag", F64_TO_UI32, RMINM, false }, + { "f64_to_ui32_r_min", F64_TO_UI32, RMIN, false }, + { "f64_to_ui32_r_max", F64_TO_UI32, RMAX, false }, + { "f64_to_ui32_r_near_maxMag", F64_TO_UI32, RNMAXM, false }, + { "f64_to_ui64_r_near_even", F64_TO_UI64, RNEVEN, false }, + { "f64_to_ui64_r_minMag", F64_TO_UI64, RMINM, false }, + { "f64_to_ui64_r_min", F64_TO_UI64, RMIN, false }, + { "f64_to_ui64_r_max", F64_TO_UI64, RMAX, false }, + { "f64_to_ui64_r_near_maxMag", F64_TO_UI64, RNMAXM, false }, + { "f64_to_i32_r_near_even", F64_TO_I32, RNEVEN, false }, + { "f64_to_i32_r_minMag", F64_TO_I32, RMINM, false }, + { "f64_to_i32_r_min", F64_TO_I32, RMIN, false }, + { "f64_to_i32_r_max", F64_TO_I32, RMAX, false }, + { "f64_to_i32_r_near_maxMag", F64_TO_I32, RNMAXM, false }, + { "f64_to_i64_r_near_even", F64_TO_I64, RNEVEN, false }, + { "f64_to_i64_r_minMag", F64_TO_I64, RMINM, false }, + { "f64_to_i64_r_min", F64_TO_I64, RMIN, false }, + { "f64_to_i64_r_max", F64_TO_I64, RMAX, false }, + { "f64_to_i64_r_near_maxMag", F64_TO_I64, RNMAXM, false }, + { "f64_to_ui32_rx_near_even", F64_TO_UI32, RNEVEN, true }, + { "f64_to_ui32_rx_minMag", F64_TO_UI32, RMINM, true }, + { "f64_to_ui32_rx_min", F64_TO_UI32, RMIN, true }, + { "f64_to_ui32_rx_max", F64_TO_UI32, RMAX, true }, + { "f64_to_ui32_rx_near_maxMag", F64_TO_UI32, RNMAXM, true }, + { "f64_to_ui64_rx_near_even", F64_TO_UI64, RNEVEN, true }, + { "f64_to_ui64_rx_minMag", F64_TO_UI64, RMINM, true }, + { "f64_to_ui64_rx_min", F64_TO_UI64, RMIN, true }, + { "f64_to_ui64_rx_max", F64_TO_UI64, RMAX, true }, + { "f64_to_ui64_rx_near_maxMag", F64_TO_UI64, RNMAXM, true }, + { "f64_to_i32_rx_near_even", F64_TO_I32, RNEVEN, true }, + { "f64_to_i32_rx_minMag", F64_TO_I32, RMINM, true }, + { "f64_to_i32_rx_min", F64_TO_I32, RMIN, true }, + { "f64_to_i32_rx_max", F64_TO_I32, RMAX, true }, + { "f64_to_i32_rx_near_maxMag", F64_TO_I32, RNMAXM, true }, + { "f64_to_i64_rx_near_even", F64_TO_I64, RNEVEN, true }, + { "f64_to_i64_rx_minMag", F64_TO_I64, RMINM, true }, + { "f64_to_i64_rx_min", F64_TO_I64, RMIN, true }, + { "f64_to_i64_rx_max", F64_TO_I64, RMAX, true }, + { "f64_to_i64_rx_near_maxMag", F64_TO_I64, RNMAXM, true }, +#ifdef FLOAT16 + { "f64_to_f16", F64_TO_F16, 0, 0 }, +#endif + { "f64_to_f32", F64_TO_F32, 0, 0 }, +#ifdef EXTFLOAT80 + { "f64_to_extF80", F64_TO_EXTF80, 0, 0 }, +#endif +#ifdef FLOAT128 + { "f64_to_f128", F64_TO_F128, 0, 0 }, +#endif + { "f64_roundToInt_r_near_even", F64_ROUNDTOINT, RNEVEN, false }, + { "f64_roundToInt_r_minMag", F64_ROUNDTOINT, RMINM, false }, + { "f64_roundToInt_r_min", F64_ROUNDTOINT, RMIN, false }, + { "f64_roundToInt_r_max", F64_ROUNDTOINT, RMAX, false }, + { "f64_roundToInt_r_near_maxMag", F64_ROUNDTOINT, RNMAXM, false }, + { "f64_roundToInt_x", F64_ROUNDTOINT, 0, true }, + { "f64_add", F64_ADD, 0, 0 }, + { "f64_sub", F64_SUB, 0, 0 }, + { "f64_mul", F64_MUL, 0, 0 }, + { "f64_mulAdd", F64_MULADD, 0, 0 }, + { "f64_div", F64_DIV, 0, 0 }, + { "f64_rem", F64_REM, 0, 0 }, + { "f64_sqrt", F64_SQRT, 0, 0 }, + { "f64_eq", F64_EQ, 0, 0 }, + { "f64_le", F64_LE, 0, 0 }, + { "f64_lt", F64_LT, 0, 0 }, + { "f64_eq_signaling", F64_EQ_SIGNALING, 0, 0 }, + { "f64_le_quiet", F64_LE_QUIET, 0, 0 }, + { "f64_lt_quiet", F64_LT_QUIET, 0, 0 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef EXTFLOAT80 + { "extF80_to_ui32_r_near_even", EXTF80_TO_UI32, RNEVEN, false }, + { "extF80_to_ui32_r_minMag", EXTF80_TO_UI32, RMINM, false }, + { "extF80_to_ui32_r_min", EXTF80_TO_UI32, RMIN, false }, + { "extF80_to_ui32_r_max", EXTF80_TO_UI32, RMAX, false }, + { "extF80_to_ui32_r_near_maxMag", EXTF80_TO_UI32, RNMAXM, false }, + { "extF80_to_ui64_r_near_even", EXTF80_TO_UI64, RNEVEN, false }, + { "extF80_to_ui64_r_minMag", EXTF80_TO_UI64, RMINM, false }, + { "extF80_to_ui64_r_min", EXTF80_TO_UI64, RMIN, false }, + { "extF80_to_ui64_r_max", EXTF80_TO_UI64, RMAX, false }, + { "extF80_to_ui64_r_near_maxMag", EXTF80_TO_UI64, RNMAXM, false }, + { "extF80_to_i32_r_near_even", EXTF80_TO_I32, RNEVEN, false }, + { "extF80_to_i32_r_minMag", EXTF80_TO_I32, RMINM, false }, + { "extF80_to_i32_r_min", EXTF80_TO_I32, RMIN, false }, + { "extF80_to_i32_r_max", EXTF80_TO_I32, RMAX, false }, + { "extF80_to_i32_r_near_maxMag", EXTF80_TO_I32, RNMAXM, false }, + { "extF80_to_i64_r_near_even", EXTF80_TO_I64, RNEVEN, false }, + { "extF80_to_i64_r_minMag", EXTF80_TO_I64, RMINM, false }, + { "extF80_to_i64_r_min", EXTF80_TO_I64, RMIN, false }, + { "extF80_to_i64_r_max", EXTF80_TO_I64, RMAX, false }, + { "extF80_to_i64_r_near_maxMag", EXTF80_TO_I64, RNMAXM, false }, + { "extF80_to_ui32_rx_near_even", EXTF80_TO_UI32, RNEVEN, true }, + { "extF80_to_ui32_rx_minMag", EXTF80_TO_UI32, RMINM, true }, + { "extF80_to_ui32_rx_min", EXTF80_TO_UI32, RMIN, true }, + { "extF80_to_ui32_rx_max", EXTF80_TO_UI32, RMAX, true }, + { "extF80_to_ui32_rx_near_maxMag", EXTF80_TO_UI32, RNMAXM, true }, + { "extF80_to_ui64_rx_near_even", EXTF80_TO_UI64, RNEVEN, true }, + { "extF80_to_ui64_rx_minMag", EXTF80_TO_UI64, RMINM, true }, + { "extF80_to_ui64_rx_min", EXTF80_TO_UI64, RMIN, true }, + { "extF80_to_ui64_rx_max", EXTF80_TO_UI64, RMAX, true }, + { "extF80_to_ui64_rx_near_maxMag", EXTF80_TO_UI64, RNMAXM, true }, + { "extF80_to_i32_rx_near_even", EXTF80_TO_I32, RNEVEN, true }, + { "extF80_to_i32_rx_minMag", EXTF80_TO_I32, RMINM, true }, + { "extF80_to_i32_rx_min", EXTF80_TO_I32, RMIN, true }, + { "extF80_to_i32_rx_max", EXTF80_TO_I32, RMAX, true }, + { "extF80_to_i32_rx_near_maxMag", EXTF80_TO_I32, RNMAXM, true }, + { "extF80_to_i64_rx_near_even", EXTF80_TO_I64, RNEVEN, true }, + { "extF80_to_i64_rx_minMag", EXTF80_TO_I64, RMINM, true }, + { "extF80_to_i64_rx_min", EXTF80_TO_I64, RMIN, true }, + { "extF80_to_i64_rx_max", EXTF80_TO_I64, RMAX, true }, + { "extF80_to_i64_rx_near_maxMag", EXTF80_TO_I64, RNMAXM, true }, +#ifdef FLOAT16 + { "extF80_to_f16", EXTF80_TO_F16, 0, 0 }, +#endif + { "extF80_to_f32", EXTF80_TO_F32, 0, 0 }, +#ifdef FLOAT64 + { "extF80_to_f64", EXTF80_TO_F64, 0, 0 }, +#endif +#ifdef FLOAT128 + { "extF80_to_f128", EXTF80_TO_F128, 0, 0 }, +#endif + { "extF80_roundToInt_r_near_even", EXTF80_ROUNDTOINT, RNEVEN, false }, + { "extF80_roundToInt_r_minMag", EXTF80_ROUNDTOINT, RMINM, false }, + { "extF80_roundToInt_r_min", EXTF80_ROUNDTOINT, RMIN, false }, + { "extF80_roundToInt_r_max", EXTF80_ROUNDTOINT, RMAX, false }, + { "extF80_roundToInt_r_near_maxMag", EXTF80_ROUNDTOINT, RNMAXM, false }, + { "extF80_roundToInt_x", EXTF80_ROUNDTOINT, 0, true }, + { "extF80_add", EXTF80_ADD, 0, 0 }, + { "extF80_sub", EXTF80_SUB, 0, 0 }, + { "extF80_mul", EXTF80_MUL, 0, 0 }, + { "extF80_div", EXTF80_DIV, 0, 0 }, + { "extF80_rem", EXTF80_REM, 0, 0 }, + { "extF80_sqrt", EXTF80_SQRT, 0, 0 }, + { "extF80_eq", EXTF80_EQ, 0, 0 }, + { "extF80_le", EXTF80_LE, 0, 0 }, + { "extF80_lt", EXTF80_LT, 0, 0 }, + { "extF80_eq_signaling", EXTF80_EQ_SIGNALING, 0, 0 }, + { "extF80_le_quiet", EXTF80_LE_QUIET, 0, 0 }, + { "extF80_lt_quiet", EXTF80_LT_QUIET, 0, 0 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT128 + { "f128_to_ui32_r_near_even", F128_TO_UI32, RNEVEN, false }, + { "f128_to_ui32_r_minMag", F128_TO_UI32, RMINM, false }, + { "f128_to_ui32_r_min", F128_TO_UI32, RMIN, false }, + { "f128_to_ui32_r_max", F128_TO_UI32, RMAX, false }, + { "f128_to_ui32_r_near_maxMag", F128_TO_UI32, RNMAXM, false }, + { "f128_to_ui64_r_near_even", F128_TO_UI64, RNEVEN, false }, + { "f128_to_ui64_r_minMag", F128_TO_UI64, RMINM, false }, + { "f128_to_ui64_r_min", F128_TO_UI64, RMIN, false }, + { "f128_to_ui64_r_max", F128_TO_UI64, RMAX, false }, + { "f128_to_ui64_r_near_maxMag", F128_TO_UI64, RNMAXM, false }, + { "f128_to_i32_r_near_even", F128_TO_I32, RNEVEN, false }, + { "f128_to_i32_r_minMag", F128_TO_I32, RMINM, false }, + { "f128_to_i32_r_min", F128_TO_I32, RMIN, false }, + { "f128_to_i32_r_max", F128_TO_I32, RMAX, false }, + { "f128_to_i32_r_near_maxMag", F128_TO_I32, RNMAXM, false }, + { "f128_to_i64_r_near_even", F128_TO_I64, RNEVEN, false }, + { "f128_to_i64_r_minMag", F128_TO_I64, RMINM, false }, + { "f128_to_i64_r_min", F128_TO_I64, RMIN, false }, + { "f128_to_i64_r_max", F128_TO_I64, RMAX, false }, + { "f128_to_i64_r_near_maxMag", F128_TO_I64, RNMAXM, false }, + { "f128_to_ui32_rx_near_even", F128_TO_UI32, RNEVEN, true }, + { "f128_to_ui32_rx_minMag", F128_TO_UI32, RMINM, true }, + { "f128_to_ui32_rx_min", F128_TO_UI32, RMIN, true }, + { "f128_to_ui32_rx_max", F128_TO_UI32, RMAX, true }, + { "f128_to_ui32_rx_near_maxMag", F128_TO_UI32, RNMAXM, true }, + { "f128_to_ui64_rx_near_even", F128_TO_UI64, RNEVEN, true }, + { "f128_to_ui64_rx_minMag", F128_TO_UI64, RMINM, true }, + { "f128_to_ui64_rx_min", F128_TO_UI64, RMIN, true }, + { "f128_to_ui64_rx_max", F128_TO_UI64, RMAX, true }, + { "f128_to_ui64_rx_near_maxMag", F128_TO_UI64, RNMAXM, true }, + { "f128_to_i32_rx_near_even", F128_TO_I32, RNEVEN, true }, + { "f128_to_i32_rx_minMag", F128_TO_I32, RMINM, true }, + { "f128_to_i32_rx_min", F128_TO_I32, RMIN, true }, + { "f128_to_i32_rx_max", F128_TO_I32, RMAX, true }, + { "f128_to_i32_rx_near_maxMag", F128_TO_I32, RNMAXM, true }, + { "f128_to_i64_rx_near_even", F128_TO_I64, RNEVEN, true }, + { "f128_to_i64_rx_minMag", F128_TO_I64, RMINM, true }, + { "f128_to_i64_rx_min", F128_TO_I64, RMIN, true }, + { "f128_to_i64_rx_max", F128_TO_I64, RMAX, true }, + { "f128_to_i64_rx_near_maxMag", F128_TO_I64, RNMAXM, true }, +#ifdef FLOAT16 + { "f128_to_f16", F128_TO_F16, 0, 0 }, +#endif + { "f128_to_f32", F128_TO_F32, 0, 0 }, +#ifdef FLOAT64 + { "f128_to_f64", F128_TO_F64, 0, 0 }, +#endif +#ifdef EXTFLOAT80 + { "f128_to_extF80", F128_TO_EXTF80, 0, 0 }, +#endif + { "f128_roundToInt_r_near_even", F128_ROUNDTOINT, RNEVEN, false }, + { "f128_roundToInt_r_minMag", F128_ROUNDTOINT, RMINM, false }, + { "f128_roundToInt_r_min", F128_ROUNDTOINT, RMIN, false }, + { "f128_roundToInt_r_max", F128_ROUNDTOINT, RMAX, false }, + { "f128_roundToInt_r_near_maxMag", F128_ROUNDTOINT, RNMAXM, false }, + { "f128_roundToInt_x", F128_ROUNDTOINT, 0, true }, + { "f128_add", F128_ADD, 0, 0 }, + { "f128_sub", F128_SUB, 0, 0 }, + { "f128_mul", F128_MUL, 0, 0 }, + { "f128_mulAdd", F128_MULADD, 0, 0 }, + { "f128_div", F128_DIV, 0, 0 }, + { "f128_rem", F128_REM, 0, 0 }, + { "f128_sqrt", F128_SQRT, 0, 0 }, + { "f128_eq", F128_EQ, 0, 0 }, + { "f128_le", F128_LE, 0, 0 }, + { "f128_lt", F128_LT, 0, 0 }, + { "f128_eq_signaling", F128_EQ_SIGNALING, 0, 0 }, + { "f128_le_quiet", F128_LE_QUIET, 0, 0 }, + { "f128_lt_quiet", F128_LT_QUIET, 0, 0 }, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + { 0, 0, 0, 0 } +}; + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat.c new file mode 100644 index 000000000..438d0ea37 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat.c @@ -0,0 +1,856 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "subjfloat_config.h" +#include "subjfloat.h" + +#pragma STDC FENV_ACCESS ON + +void subjfloat_setRoundingMode( uint_fast8_t roundingMode ) +{ + + fesetround( + (roundingMode == softfloat_round_near_even) ? FE_TONEAREST + : (roundingMode == softfloat_round_minMag) ? FE_TOWARDZERO + : (roundingMode == softfloat_round_min) ? FE_DOWNWARD + : FE_UPWARD + ); + +} + +void subjfloat_setExtF80RoundingPrecision( uint_fast8_t roundingPrecision ) +{ + +} + +uint_fast8_t subjfloat_clearExceptionFlags( void ) +{ + int subjExceptionFlags; + uint_fast8_t exceptionFlags; + + subjExceptionFlags = + fetestexcept( + FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT + ); + feclearexcept( + FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INEXACT ); + exceptionFlags = 0; + if ( subjExceptionFlags & FE_INVALID ) { + exceptionFlags |= softfloat_flag_invalid; + } + if ( subjExceptionFlags & FE_DIVBYZERO ) { + exceptionFlags |= softfloat_flag_infinite; + } + if ( subjExceptionFlags & FE_OVERFLOW ) { + exceptionFlags |= softfloat_flag_overflow; + } + if ( subjExceptionFlags & FE_UNDERFLOW ) { + exceptionFlags |= softfloat_flag_underflow; + } + if ( subjExceptionFlags & FE_INEXACT ) { + exceptionFlags |= softfloat_flag_inexact; + } + return exceptionFlags; + +} + +union f32_f { float32_t f32; float f; }; + +float32_t subj_ui32_to_f32( uint32_t a ) +{ + union f32_f uZ; + + uZ.f = a; + return uZ.f32; + +} + +float32_t subj_ui64_to_f32( uint64_t a ) +{ + union f32_f uZ; + + uZ.f = a; + return uZ.f32; + +} + +float32_t subj_i32_to_f32( int32_t a ) +{ + union f32_f uZ; + + uZ.f = a; + return uZ.f32; + +} + +float32_t subj_i64_to_f32( int64_t a ) +{ + union f32_f uZ; + + uZ.f = a; + return uZ.f32; + +} + +uint_fast32_t subj_f32_to_ui32_rx_minMag( float32_t a ) +{ + union f32_f uA; + + uA.f32 = a; + return (uint32_t) uA.f; + +} + +uint_fast64_t subj_f32_to_ui64_rx_minMag( float32_t a ) +{ + union f32_f uA; + + uA.f32 = a; + return (uint64_t) uA.f; + +} + +int_fast32_t subj_f32_to_i32_rx_minMag( float32_t a ) +{ + union f32_f uA; + + uA.f32 = a; + return (int32_t) uA.f; + +} + +int_fast64_t subj_f32_to_i64_rx_minMag( float32_t a ) +{ + union f32_f uA; + + uA.f32 = a; + return (int64_t) uA.f; + +} + +float32_t subj_f32_add( float32_t a, float32_t b ) +{ + union f32_f uA, uB, uZ; + + uA.f32 = a; + uB.f32 = b; + uZ.f = uA.f + uB.f; + return uZ.f32; + +} + +float32_t subj_f32_sub( float32_t a, float32_t b ) +{ + union f32_f uA, uB, uZ; + + uA.f32 = a; + uB.f32 = b; + uZ.f = uA.f - uB.f; + return uZ.f32; + +} + +float32_t subj_f32_mul( float32_t a, float32_t b ) +{ + union f32_f uA, uB, uZ; + + uA.f32 = a; + uB.f32 = b; + uZ.f = uA.f * uB.f; + return uZ.f32; + +} + +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ + +float32_t subj_f32_mulAdd( float32_t a, float32_t b, float32_t c ) +{ + union f32_f uA, uB, uC, uZ; + + uA.f32 = a; + uB.f32 = b; + uC.f32 = c; + uZ.f = fmaf( uA.f, uB.f, uC.f ); + return uZ.f32; + +} + +#endif +#endif + +float32_t subj_f32_div( float32_t a, float32_t b ) +{ + union f32_f uA, uB, uZ; + + uA.f32 = a; + uB.f32 = b; + uZ.f = uA.f / uB.f; + return uZ.f32; + +} + +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ + +float32_t subj_f32_sqrt( float32_t a ) +{ + union f32_f uA, uZ; + + uA.f32 = a; + uZ.f = sqrtf( uA.f ); + return uZ.f32; + +} + +#endif +#endif + +bool subj_f32_eq( float32_t a, float32_t b ) +{ + union f32_f uA, uB; + + uA.f32 = a; + uB.f32 = b; + return (uA.f == uB.f); + +} + +bool subj_f32_le( float32_t a, float32_t b ) +{ + union f32_f uA, uB; + + uA.f32 = a; + uB.f32 = b; + return (uA.f <= uB.f); + +} + +bool subj_f32_lt( float32_t a, float32_t b ) +{ + union f32_f uA, uB; + + uA.f32 = a; + uB.f32 = b; + return (uA.f < uB.f); + +} + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +#ifdef FLOAT64 + +union f64_d { float64_t f64; double d; }; + +float64_t subj_ui32_to_f64( uint32_t a ) +{ + union f64_d uZ; + + uZ.d = a; + return uZ.f64; + +} + +float64_t subj_ui64_to_f64( uint64_t a ) +{ + union f64_d uZ; + + uZ.d = a; + return uZ.f64; + +} + +float64_t subj_i32_to_f64( int32_t a ) +{ + union f64_d uZ; + + uZ.d = a; + return uZ.f64; + +} + +float64_t subj_i64_to_f64( int64_t a ) +{ + union f64_d uZ; + + uZ.d = a; + return uZ.f64; + +} + +float64_t subj_f32_to_f64( float32_t a ) +{ + union f32_f uA; + union f64_d uZ; + + uA.f32 = a; + uZ.d = uA.f; + return uZ.f64; + +} + +uint_fast32_t subj_f64_to_ui32_rx_minMag( float64_t a ) +{ + union f64_d uA; + + uA.f64 = a; + return (uint32_t) uA.d; + +} + +uint_fast64_t subj_f64_to_ui64_rx_minMag( float64_t a ) +{ + union f64_d uA; + + uA.f64 = a; + return (uint64_t) uA.d; + +} + +int_fast32_t subj_f64_to_i32_rx_minMag( float64_t a ) +{ + union f64_d uA; + + uA.f64 = a; + return (int32_t) uA.d; + +} + +int_fast64_t subj_f64_to_i64_rx_minMag( float64_t a ) +{ + union f64_d uA; + + uA.f64 = a; + return (int64_t) uA.d; + +} + +float32_t subj_f64_to_f32( float64_t a ) +{ + union f64_d uA; + union f32_f uZ; + + uA.f64 = a; + uZ.f = uA.d; + return uZ.f32; + +} + +float64_t subj_f64_add( float64_t a, float64_t b ) +{ + union f64_d uA, uB, uZ; + + uA.f64 = a; + uB.f64 = b; + uZ.d = uA.d + uB.d; + return uZ.f64; + +} + +float64_t subj_f64_sub( float64_t a, float64_t b ) +{ + union f64_d uA, uB, uZ; + + uA.f64 = a; + uB.f64 = b; + uZ.d = uA.d - uB.d; + return uZ.f64; + +} + +float64_t subj_f64_mul( float64_t a, float64_t b ) +{ + union f64_d uA, uB, uZ; + + uA.f64 = a; + uB.f64 = b; + uZ.d = uA.d * uB.d; + return uZ.f64; + +} + +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ + +float64_t subj_f64_mulAdd( float64_t a, float64_t b, float64_t c ) +{ + union f64_d uA, uB, uC, uZ; + + uA.f64 = a; + uB.f64 = b; + uC.f64 = c; + uZ.d = fma( uA.d, uB.d, uC.d ); + return uZ.f64; + +} + +#endif +#endif + +float64_t subj_f64_div( float64_t a, float64_t b ) +{ + union f64_d uA, uB, uZ; + + uA.f64 = a; + uB.f64 = b; + uZ.d = uA.d / uB.d; + return uZ.f64; + +} + +float64_t subj_f64_sqrt( float64_t a ) +{ + union f64_d uA, uZ; + + uA.f64 = a; + uZ.d = sqrt( uA.d ); + return uZ.f64; + +} + +bool subj_f64_eq( float64_t a, float64_t b ) +{ + union f64_d uA, uB; + + uA.f64 = a; + uB.f64 = b; + return (uA.d == uB.d); + +} + +bool subj_f64_le( float64_t a, float64_t b ) +{ + union f64_d uA, uB; + + uA.f64 = a; + uB.f64 = b; + return (uA.d <= uB.d); + +} + +bool subj_f64_lt( float64_t a, float64_t b ) +{ + union f64_d uA, uB; + + uA.f64 = a; + uB.f64 = b; + return (uA.d < uB.d); + +} + +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +#if defined EXTFLOAT80 && defined LONG_DOUBLE_IS_EXTFLOAT80 + +void subj_ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_i32_to_extF80M( int32_t a, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_i64_to_extF80M( int64_t a, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_f32_to_extF80M( float32_t a, extFloat80_t *zPtr ) +{ + union f32_f uA; + + uA.f32 = a; + *((long double *) zPtr) = uA.f; + +} + +#ifdef FLOAT64 + +void subj_f64_to_extF80M( float64_t a, extFloat80_t *zPtr ) +{ + union f64_d uA; + + uA.f64 = a; + *((long double *) zPtr) = uA.d; + +} + +#endif + +uint_fast32_t subj_extF80M_to_ui32_rx_minMag( const extFloat80_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +uint_fast64_t subj_extF80M_to_ui64_rx_minMag( const extFloat80_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +int_fast32_t subj_extF80M_to_i32_rx_minMag( const extFloat80_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +int_fast64_t subj_extF80M_to_i64_rx_minMag( const extFloat80_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +float32_t subj_extF80M_to_f32( const extFloat80_t *aPtr ) +{ + union f32_f uZ; + + uZ.f = *((const long double *) aPtr); + return uZ.f32; + +} + +#ifdef FLOAT64 + +float64_t subj_extF80M_to_f64( const extFloat80_t *aPtr ) +{ + union f64_d uZ; + + uZ.d = *((const long double *) aPtr); + return uZ.f64; + +} + +#endif + +void + subj_extF80M_add( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) + *((const long double *) bPtr); + +} + +void + subj_extF80M_sub( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) - *((const long double *) bPtr); + +} + +void + subj_extF80M_mul( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) * *((const long double *) bPtr); + +} + +void + subj_extF80M_div( + const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) / *((const long double *) bPtr); + +} + +bool subj_extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return (*((const long double *) aPtr) == *((const long double *) bPtr)); + +} + +bool subj_extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return (*((const long double *) aPtr) <= *((const long double *) bPtr)); + +} + +bool subj_extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr ) +{ + + return (*((const long double *) aPtr) < *((const long double *) bPtr)); + +} + +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ + +#if defined FLOAT128 && defined LONG_DOUBLE_IS_FLOAT128 + +void subj_ui32_to_f128M( uint32_t a, float128_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_ui64_to_f128M( uint64_t a, float128_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_i32_to_f128M( int32_t a, float128_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_i64_to_f128M( int64_t a, float128_t *zPtr ) +{ + + *((long double *) zPtr) = a; + +} + +void subj_f32_to_f128M( float32_t a, float128_t *zPtr ) +{ + union f32_f uA; + + uA.f32 = a; + *((long double *) zPtr) = uA.f; + +} + +#ifdef FLOAT64 + +void subj_f64_to_f128M( float64_t a, float128_t *zPtr ) +{ + union f64_d uA; + + uA.f64 = a; + *((long double *) zPtr) = uA.d; + +} + +#endif + +uint_fast32_t subj_f128M_to_ui32_rx_minMag( const float128_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +uint_fast64_t subj_f128M_to_ui64_rx_minMag( const float128_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +int_fast32_t subj_f128M_to_i32_rx_minMag( const float128_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +int_fast64_t subj_f128M_to_i64_rx_minMag( const float128_t *aPtr ) +{ + + return *((const long double *) aPtr); + +} + +float32_t subj_f128M_to_f32( const float128_t *aPtr ) +{ + union f32_f uZ; + + uZ.f = *((const long double *) aPtr); + return uZ.f32; + +} + +#ifdef FLOAT64 + +float64_t subj_f128M_to_f64( const float128_t *aPtr ) +{ + union f64_d uZ; + + uZ.d = *((const long double *) aPtr); + return uZ.f64; + +} + +#endif + +void + subj_f128M_add( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) + *((const long double *) bPtr); + +} + +void + subj_f128M_sub( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) - *((const long double *) bPtr); + +} + +void + subj_f128M_mul( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) * *((const long double *) bPtr); + +} + +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ + +void + subj_f128M_mulAdd( + const float128_t *aPtr, + const float128_t *bPtr, + const float128_t *cPtr, + float128_t *zPtr + ) +{ + + *((long double *) zPtr) = + fmal( + *((const long double *) aPtr), + *((const long double *) bPtr), + *((const long double *) cPtr) + ); + +} + +#endif +#endif + +void + subj_f128M_div( + const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr ) +{ + + *((long double *) zPtr) = + *((const long double *) aPtr) / *((const long double *) bPtr); + +} + +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ + +void subj_f128M_sqrt( const float128_t *aPtr, float128_t *zPtr ) +{ + + *((long double *) zPtr) = sqrtl( *((const long double *) aPtr) ); + +} + +#endif +#endif + +bool subj_f128M_eq( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return (*((const long double *) aPtr) == *((const long double *) bPtr)); + +} + +bool subj_f128M_le( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return (*((const long double *) aPtr) <= *((const long double *) bPtr)); + +} + +bool subj_f128M_lt( const float128_t *aPtr, const float128_t *bPtr ) +{ + + return (*((const long double *) aPtr) < *((const long double *) bPtr)); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat_config.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat_config.h new file mode 100644 index 000000000..01387e6d1 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/subj-C/subjfloat_config.h @@ -0,0 +1,133 @@ + +/*---------------------------------------------------------------------------- +| The following macros are defined to indicate all the subject functions that +| exist. +*----------------------------------------------------------------------------*/ + +#define SUBJ_UI32_TO_F32 +#define SUBJ_UI64_TO_F32 +#define SUBJ_I32_TO_F32 +#define SUBJ_I64_TO_F32 + +#define SUBJ_F32_TO_UI32_RX_MINMAG +#define SUBJ_F32_TO_UI64_RX_MINMAG +#define SUBJ_F32_TO_I32_RX_MINMAG +#define SUBJ_F32_TO_I64_RX_MINMAG +#define SUBJ_F32_ADD +#define SUBJ_F32_SUB +#define SUBJ_F32_MUL +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ +#define SUBJ_F32_MULADD +#endif +#endif +#define SUBJ_F32_DIV +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ +#define SUBJ_F32_SQRT +#endif +#endif +#define SUBJ_F32_EQ +#define SUBJ_F32_LE +#define SUBJ_F32_LT + +#ifdef FLOAT64 + +#define SUBJ_UI32_TO_F64 +#define SUBJ_UI64_TO_F64 +#define SUBJ_I32_TO_F64 +#define SUBJ_I64_TO_F64 + +#define SUBJ_F32_TO_F64 + +#define SUBJ_F64_TO_UI32_RX_MINMAG +#define SUBJ_F64_TO_UI64_RX_MINMAG +#define SUBJ_F64_TO_I32_RX_MINMAG +#define SUBJ_F64_TO_I64_RX_MINMAG +#define SUBJ_F64_TO_F32 +#define SUBJ_F64_ADD +#define SUBJ_F64_SUB +#define SUBJ_F64_MUL +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ +#define SUBJ_F64_MULADD +#endif +#endif +#define SUBJ_F64_DIV +#define SUBJ_F64_SQRT +#define SUBJ_F64_EQ +#define SUBJ_F64_LE +#define SUBJ_F64_LT + +#endif + +#if defined EXTFLOAT80 && defined LONG_DOUBLE_IS_EXTFLOAT80 + +#define SUBJ_UI32_TO_EXTF80 +#define SUBJ_UI64_TO_EXTF80 +#define SUBJ_I32_TO_EXTF80 +#define SUBJ_I64_TO_EXTF80 + +#define SUBJ_F32_TO_EXTF80 +#ifdef FLOAT64 +#define SUBJ_F64_TO_EXTF80 +#endif + +#define SUBJ_EXTF80_TO_UI32_RX_MINMAG +#define SUBJ_EXTF80_TO_UI64_RX_MINMAG +#define SUBJ_EXTF80_TO_I32_RX_MINMAG +#define SUBJ_EXTF80_TO_I64_RX_MINMAG +#define SUBJ_EXTF80_TO_F32 +#ifdef FLOAT64 +#define SUBJ_EXTF80_TO_F64 +#endif +#define SUBJ_EXTF80_ADD +#define SUBJ_EXTF80_SUB +#define SUBJ_EXTF80_MUL +#define SUBJ_EXTF80_DIV +#define SUBJ_EXTF80_EQ +#define SUBJ_EXTF80_LE +#define SUBJ_EXTF80_LT + +#endif + +#if defined FLOAT128 && defined LONG_DOUBLE_IS_FLOAT128 + +#define SUBJ_UI32_TO_F128 +#define SUBJ_UI64_TO_F128 +#define SUBJ_I32_TO_F128 +#define SUBJ_I64_TO_F128 + +#define SUBJ_F32_TO_F128 +#ifdef FLOAT64 +#define SUBJ_F64_TO_F128 +#endif + +#define SUBJ_F128_TO_UI32_RX_MINMAG +#define SUBJ_F128_TO_UI64_RX_MINMAG +#define SUBJ_F128_TO_I32_RX_MINMAG +#define SUBJ_F128_TO_I64_RX_MINMAG +#define SUBJ_F128_TO_F32 +#ifdef FLOAT64 +#define SUBJ_F128_TO_F64 +#endif +#define SUBJ_F128_ADD +#define SUBJ_F128_SUB +#define SUBJ_F128_MUL +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ +#define SUBJ_F128_MULADD +#endif +#endif +#define SUBJ_F128_DIV +#ifdef __STDC_VERSION__ +#if 199901L <= __STDC_VERSION__ +#define SUBJ_F128_SQRT +#endif +#endif +#define SUBJ_F128_EQ +#define SUBJ_F128_LE +#define SUBJ_F128_LT + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat.h new file mode 100644 index 000000000..43076deee --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat.h @@ -0,0 +1,516 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "softfloat.h" + +extern void (*const subjfloat_functions[])(); + +void subjfloat_setRoundingMode( uint_fast8_t ); +void subjfloat_setExtF80RoundingPrecision( uint_fast8_t ); +uint_fast8_t subjfloat_clearExceptionFlags( void ); + +/*---------------------------------------------------------------------------- +| Subject function declarations. (Many of these functions may not exist.) +| WARNING: +| This file should not normally be modified. Use "subjfloat_config.h" to +| specify which of these functions actually exist. +*----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT16 +float16_t subj_ui32_to_f16( uint32_t ); +#endif +float32_t subj_ui32_to_f32( uint32_t ); +#ifdef FLOAT64 +float64_t subj_ui32_to_f64( uint32_t ); +#endif +#ifdef EXTFLOAT80 +void subj_ui32_to_extF80M( uint32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void subj_ui32_to_f128M( uint32_t, float128_t * ); +#endif +#ifdef FLOAT16 +float16_t subj_ui64_to_f16( uint64_t ); +#endif +float32_t subj_ui64_to_f32( uint64_t ); +#ifdef FLOAT64 +float64_t subj_ui64_to_f64( uint64_t ); +#endif +#ifdef EXTFLOAT80 +void subj_ui64_to_extF80M( uint64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void subj_ui64_to_f128M( uint64_t, float128_t * ); +#endif +#ifdef FLOAT16 +float16_t subj_i32_to_f16( int32_t ); +#endif +float32_t subj_i32_to_f32( int32_t ); +#ifdef FLOAT64 +float64_t subj_i32_to_f64( int32_t ); +#endif +#ifdef EXTFLOAT80 +void subj_i32_to_extF80M( int32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void subj_i32_to_f128M( int32_t, float128_t * ); +#endif +#ifdef FLOAT16 +float16_t subj_i64_to_f16( int64_t ); +#endif +float32_t subj_i64_to_f32( int64_t ); +#ifdef FLOAT64 +float64_t subj_i64_to_f64( int64_t ); +#endif +#ifdef EXTFLOAT80 +void subj_i64_to_extF80M( int64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void subj_i64_to_f128M( int64_t, float128_t * ); +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT16 + +uint_fast32_t subj_f16_to_ui32_r_near_even( float16_t ); +uint_fast32_t subj_f16_to_ui32_r_minMag( float16_t ); +uint_fast32_t subj_f16_to_ui32_r_min( float16_t ); +uint_fast32_t subj_f16_to_ui32_r_max( float16_t ); +uint_fast32_t subj_f16_to_ui32_r_near_maxMag( float16_t ); +uint_fast64_t subj_f16_to_ui64_r_near_even( float16_t ); +uint_fast64_t subj_f16_to_ui64_r_minMag( float16_t ); +uint_fast64_t subj_f16_to_ui64_r_min( float16_t ); +uint_fast64_t subj_f16_to_ui64_r_max( float16_t ); +uint_fast64_t subj_f16_to_ui64_r_near_maxMag( float16_t ); +int_fast32_t subj_f16_to_i32_r_near_even( float16_t ); +int_fast32_t subj_f16_to_i32_r_minMag( float16_t ); +int_fast32_t subj_f16_to_i32_r_min( float16_t ); +int_fast32_t subj_f16_to_i32_r_max( float16_t ); +int_fast32_t subj_f16_to_i32_r_near_maxMag( float16_t ); +int_fast64_t subj_f16_to_i64_r_near_even( float16_t ); +int_fast64_t subj_f16_to_i64_r_minMag( float16_t ); +int_fast64_t subj_f16_to_i64_r_min( float16_t ); +int_fast64_t subj_f16_to_i64_r_max( float16_t ); +int_fast64_t subj_f16_to_i64_r_near_maxMag( float16_t ); + +uint_fast32_t subj_f16_to_ui32_rx_near_even( float16_t ); +uint_fast32_t subj_f16_to_ui32_rx_minMag( float16_t ); +uint_fast32_t subj_f16_to_ui32_rx_min( float16_t ); +uint_fast32_t subj_f16_to_ui32_rx_max( float16_t ); +uint_fast32_t subj_f16_to_ui32_rx_near_maxMag( float16_t ); +uint_fast64_t subj_f16_to_ui64_rx_near_even( float16_t ); +uint_fast64_t subj_f16_to_ui64_rx_minMag( float16_t ); +uint_fast64_t subj_f16_to_ui64_rx_min( float16_t ); +uint_fast64_t subj_f16_to_ui64_rx_max( float16_t ); +uint_fast64_t subj_f16_to_ui64_rx_near_maxMag( float16_t ); +int_fast32_t subj_f16_to_i32_rx_near_even( float16_t ); +int_fast32_t subj_f16_to_i32_rx_minMag( float16_t ); +int_fast32_t subj_f16_to_i32_rx_min( float16_t ); +int_fast32_t subj_f16_to_i32_rx_max( float16_t ); +int_fast32_t subj_f16_to_i32_rx_near_maxMag( float16_t ); +int_fast64_t subj_f16_to_i64_rx_near_even( float16_t ); +int_fast64_t subj_f16_to_i64_rx_minMag( float16_t ); +int_fast64_t subj_f16_to_i64_rx_min( float16_t ); +int_fast64_t subj_f16_to_i64_rx_max( float16_t ); +int_fast64_t subj_f16_to_i64_rx_near_maxMag( float16_t ); + +float32_t subj_f16_to_f32( float16_t ); +#ifdef FLOAT64 +float64_t subj_f16_to_f64( float16_t ); +#endif +#ifdef EXTFLOAT80 +void subj_f16_to_extF80M( float16_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void subj_f16_to_f128M( float16_t, float128_t * ); +#endif + +float16_t subj_f16_roundToInt_r_near_even( float16_t ); +float16_t subj_f16_roundToInt_r_minMag( float16_t ); +float16_t subj_f16_roundToInt_r_min( float16_t ); +float16_t subj_f16_roundToInt_r_max( float16_t ); +float16_t subj_f16_roundToInt_r_near_maxMag( float16_t ); +float16_t subj_f16_roundToInt_x( float16_t ); +float16_t subj_f16_add( float16_t, float16_t ); +float16_t subj_f16_sub( float16_t, float16_t ); +float16_t subj_f16_mul( float16_t, float16_t ); +float16_t subj_f16_mulAdd( float16_t, float16_t, float16_t ); +float16_t subj_f16_div( float16_t, float16_t ); +float16_t subj_f16_rem( float16_t, float16_t ); +float16_t subj_f16_sqrt( float16_t ); +bool subj_f16_eq( float16_t, float16_t ); +bool subj_f16_le( float16_t, float16_t ); +bool subj_f16_lt( float16_t, float16_t ); +bool subj_f16_eq_signaling( float16_t, float16_t ); +bool subj_f16_le_quiet( float16_t, float16_t ); +bool subj_f16_lt_quiet( float16_t, float16_t ); + +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +uint_fast32_t subj_f32_to_ui32_r_near_even( float32_t ); +uint_fast32_t subj_f32_to_ui32_r_minMag( float32_t ); +uint_fast32_t subj_f32_to_ui32_r_min( float32_t ); +uint_fast32_t subj_f32_to_ui32_r_max( float32_t ); +uint_fast32_t subj_f32_to_ui32_r_near_maxMag( float32_t ); +uint_fast64_t subj_f32_to_ui64_r_near_even( float32_t ); +uint_fast64_t subj_f32_to_ui64_r_minMag( float32_t ); +uint_fast64_t subj_f32_to_ui64_r_min( float32_t ); +uint_fast64_t subj_f32_to_ui64_r_max( float32_t ); +uint_fast64_t subj_f32_to_ui64_r_near_maxMag( float32_t ); +int_fast32_t subj_f32_to_i32_r_near_even( float32_t ); +int_fast32_t subj_f32_to_i32_r_minMag( float32_t ); +int_fast32_t subj_f32_to_i32_r_min( float32_t ); +int_fast32_t subj_f32_to_i32_r_max( float32_t ); +int_fast32_t subj_f32_to_i32_r_near_maxMag( float32_t ); +int_fast64_t subj_f32_to_i64_r_near_even( float32_t ); +int_fast64_t subj_f32_to_i64_r_minMag( float32_t ); +int_fast64_t subj_f32_to_i64_r_min( float32_t ); +int_fast64_t subj_f32_to_i64_r_max( float32_t ); +int_fast64_t subj_f32_to_i64_r_near_maxMag( float32_t ); + +uint_fast32_t subj_f32_to_ui32_rx_near_even( float32_t ); +uint_fast32_t subj_f32_to_ui32_rx_minMag( float32_t ); +uint_fast32_t subj_f32_to_ui32_rx_min( float32_t ); +uint_fast32_t subj_f32_to_ui32_rx_max( float32_t ); +uint_fast32_t subj_f32_to_ui32_rx_near_maxMag( float32_t ); +uint_fast64_t subj_f32_to_ui64_rx_near_even( float32_t ); +uint_fast64_t subj_f32_to_ui64_rx_minMag( float32_t ); +uint_fast64_t subj_f32_to_ui64_rx_min( float32_t ); +uint_fast64_t subj_f32_to_ui64_rx_max( float32_t ); +uint_fast64_t subj_f32_to_ui64_rx_near_maxMag( float32_t ); +int_fast32_t subj_f32_to_i32_rx_near_even( float32_t ); +int_fast32_t subj_f32_to_i32_rx_minMag( float32_t ); +int_fast32_t subj_f32_to_i32_rx_min( float32_t ); +int_fast32_t subj_f32_to_i32_rx_max( float32_t ); +int_fast32_t subj_f32_to_i32_rx_near_maxMag( float32_t ); +int_fast64_t subj_f32_to_i64_rx_near_even( float32_t ); +int_fast64_t subj_f32_to_i64_rx_minMag( float32_t ); +int_fast64_t subj_f32_to_i64_rx_min( float32_t ); +int_fast64_t subj_f32_to_i64_rx_max( float32_t ); +int_fast64_t subj_f32_to_i64_rx_near_maxMag( float32_t ); + +#ifdef FLOAT16 +float16_t subj_f32_to_f16( float32_t ); +#endif +#ifdef FLOAT64 +float64_t subj_f32_to_f64( float32_t ); +#endif +#ifdef EXTFLOAT80 +void subj_f32_to_extF80M( float32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void subj_f32_to_f128M( float32_t, float128_t * ); +#endif + +float32_t subj_f32_roundToInt_r_near_even( float32_t ); +float32_t subj_f32_roundToInt_r_minMag( float32_t ); +float32_t subj_f32_roundToInt_r_min( float32_t ); +float32_t subj_f32_roundToInt_r_max( float32_t ); +float32_t subj_f32_roundToInt_r_near_maxMag( float32_t ); +float32_t subj_f32_roundToInt_x( float32_t ); +float32_t subj_f32_add( float32_t, float32_t ); +float32_t subj_f32_sub( float32_t, float32_t ); +float32_t subj_f32_mul( float32_t, float32_t ); +float32_t subj_f32_mulAdd( float32_t, float32_t, float32_t ); +float32_t subj_f32_div( float32_t, float32_t ); +float32_t subj_f32_rem( float32_t, float32_t ); +float32_t subj_f32_sqrt( float32_t ); +bool subj_f32_eq( float32_t, float32_t ); +bool subj_f32_le( float32_t, float32_t ); +bool subj_f32_lt( float32_t, float32_t ); +bool subj_f32_eq_signaling( float32_t, float32_t ); +bool subj_f32_le_quiet( float32_t, float32_t ); +bool subj_f32_lt_quiet( float32_t, float32_t ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT64 + +uint_fast32_t subj_f64_to_ui32_r_near_even( float64_t ); +uint_fast32_t subj_f64_to_ui32_r_minMag( float64_t ); +uint_fast32_t subj_f64_to_ui32_r_min( float64_t ); +uint_fast32_t subj_f64_to_ui32_r_max( float64_t ); +uint_fast32_t subj_f64_to_ui32_r_near_maxMag( float64_t ); +uint_fast64_t subj_f64_to_ui64_r_near_even( float64_t ); +uint_fast64_t subj_f64_to_ui64_r_minMag( float64_t ); +uint_fast64_t subj_f64_to_ui64_r_min( float64_t ); +uint_fast64_t subj_f64_to_ui64_r_max( float64_t ); +uint_fast64_t subj_f64_to_ui64_r_near_maxMag( float64_t ); +int_fast32_t subj_f64_to_i32_r_near_even( float64_t ); +int_fast32_t subj_f64_to_i32_r_minMag( float64_t ); +int_fast32_t subj_f64_to_i32_r_min( float64_t ); +int_fast32_t subj_f64_to_i32_r_max( float64_t ); +int_fast32_t subj_f64_to_i32_r_near_maxMag( float64_t ); +int_fast64_t subj_f64_to_i64_r_near_even( float64_t ); +int_fast64_t subj_f64_to_i64_r_minMag( float64_t ); +int_fast64_t subj_f64_to_i64_r_min( float64_t ); +int_fast64_t subj_f64_to_i64_r_max( float64_t ); +int_fast64_t subj_f64_to_i64_r_near_maxMag( float64_t ); + +uint_fast32_t subj_f64_to_ui32_rx_near_even( float64_t ); +uint_fast32_t subj_f64_to_ui32_rx_minMag( float64_t ); +uint_fast32_t subj_f64_to_ui32_rx_min( float64_t ); +uint_fast32_t subj_f64_to_ui32_rx_max( float64_t ); +uint_fast32_t subj_f64_to_ui32_rx_near_maxMag( float64_t ); +uint_fast64_t subj_f64_to_ui64_rx_near_even( float64_t ); +uint_fast64_t subj_f64_to_ui64_rx_minMag( float64_t ); +uint_fast64_t subj_f64_to_ui64_rx_min( float64_t ); +uint_fast64_t subj_f64_to_ui64_rx_max( float64_t ); +uint_fast64_t subj_f64_to_ui64_rx_near_maxMag( float64_t ); +int_fast32_t subj_f64_to_i32_rx_near_even( float64_t ); +int_fast32_t subj_f64_to_i32_rx_minMag( float64_t ); +int_fast32_t subj_f64_to_i32_rx_min( float64_t ); +int_fast32_t subj_f64_to_i32_rx_max( float64_t ); +int_fast32_t subj_f64_to_i32_rx_near_maxMag( float64_t ); +int_fast64_t subj_f64_to_i64_rx_near_even( float64_t ); +int_fast64_t subj_f64_to_i64_rx_minMag( float64_t ); +int_fast64_t subj_f64_to_i64_rx_min( float64_t ); +int_fast64_t subj_f64_to_i64_rx_max( float64_t ); +int_fast64_t subj_f64_to_i64_rx_near_maxMag( float64_t ); + +#ifdef FLOAT16 +float16_t subj_f64_to_f16( float64_t ); +#endif +float32_t subj_f64_to_f32( float64_t ); +#ifdef EXTFLOAT80 +void subj_f64_to_extF80M( float64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +void subj_f64_to_f128M( float64_t, float128_t * ); +#endif + +float64_t subj_f64_roundToInt_r_near_even( float64_t ); +float64_t subj_f64_roundToInt_r_minMag( float64_t ); +float64_t subj_f64_roundToInt_r_min( float64_t ); +float64_t subj_f64_roundToInt_r_max( float64_t ); +float64_t subj_f64_roundToInt_r_near_maxMag( float64_t ); +float64_t subj_f64_roundToInt_x( float64_t ); +float64_t subj_f64_add( float64_t, float64_t ); +float64_t subj_f64_sub( float64_t, float64_t ); +float64_t subj_f64_mul( float64_t, float64_t ); +float64_t subj_f64_mulAdd( float64_t, float64_t, float64_t ); +float64_t subj_f64_div( float64_t, float64_t ); +float64_t subj_f64_rem( float64_t, float64_t ); +float64_t subj_f64_sqrt( float64_t ); +bool subj_f64_eq( float64_t, float64_t ); +bool subj_f64_le( float64_t, float64_t ); +bool subj_f64_lt( float64_t, float64_t ); +bool subj_f64_eq_signaling( float64_t, float64_t ); +bool subj_f64_le_quiet( float64_t, float64_t ); +bool subj_f64_lt_quiet( float64_t, float64_t ); + +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef EXTFLOAT80 + +uint_fast32_t subj_extF80M_to_ui32_r_near_even( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_r_minMag( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_r_min( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_r_max( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_r_near_maxMag( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_r_near_even( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_r_minMag( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_r_min( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_r_max( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_r_near_maxMag( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_r_near_even( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_r_minMag( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_r_min( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_r_max( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_r_near_maxMag( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_r_near_even( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_r_minMag( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_r_min( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_r_max( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_r_near_maxMag( const extFloat80_t * ); + +uint_fast32_t subj_extF80M_to_ui32_rx_near_even( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_rx_minMag( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_rx_min( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_rx_max( const extFloat80_t * ); +uint_fast32_t subj_extF80M_to_ui32_rx_near_maxMag( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_rx_near_even( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_rx_minMag( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_rx_min( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_rx_max( const extFloat80_t * ); +uint_fast64_t subj_extF80M_to_ui64_rx_near_maxMag( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_rx_near_even( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_rx_minMag( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_rx_min( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_rx_max( const extFloat80_t * ); +int_fast32_t subj_extF80M_to_i32_rx_near_maxMag( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_rx_near_even( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_rx_minMag( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_rx_min( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_rx_max( const extFloat80_t * ); +int_fast64_t subj_extF80M_to_i64_rx_near_maxMag( const extFloat80_t * ); + +#ifdef FLOAT16 +float16_t subj_extF80M_to_f16( const extFloat80_t * ); +#endif +float32_t subj_extF80M_to_f32( const extFloat80_t * ); +#ifdef FLOAT64 +float64_t subj_extF80M_to_f64( const extFloat80_t * ); +#endif +#ifdef EXTFLOAT80 +void subj_extF80M_to_f128M( const extFloat80_t *, float128_t * ); +#endif + +void + subj_extF80M_roundToInt_r_near_even( const extFloat80_t *, extFloat80_t * ); +void subj_extF80M_roundToInt_r_minMag( const extFloat80_t *, extFloat80_t * ); +void subj_extF80M_roundToInt_r_min( const extFloat80_t *, extFloat80_t * ); +void subj_extF80M_roundToInt_r_max( const extFloat80_t *, extFloat80_t * ); +void + subj_extF80M_roundToInt_r_near_maxMag( const extFloat80_t *, extFloat80_t * ); +void subj_extF80M_roundToInt_x( const extFloat80_t *, extFloat80_t * ); +void + subj_extF80M_add( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + subj_extF80M_sub( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + subj_extF80M_mul( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + subj_extF80M_div( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void + subj_extF80M_rem( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +void subj_extF80M_sqrt( const extFloat80_t *, extFloat80_t * ); +bool subj_extF80M_eq( const extFloat80_t *, const extFloat80_t * ); +bool subj_extF80M_le( const extFloat80_t *, const extFloat80_t * ); +bool subj_extF80M_lt( const extFloat80_t *, const extFloat80_t * ); +bool subj_extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * ); +bool subj_extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * ); +bool subj_extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * ); + +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT128 + +uint_fast32_t subj_f128M_to_ui32_r_near_even( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_r_minMag( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_r_min( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_r_max( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_r_near_maxMag( extFloat80_t * ); +uint_fast64_t subj_f128M_to_ui64_r_near_even( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_r_minMag( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_r_min( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_r_max( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_r_near_maxMag( extFloat80_t * ); +int_fast32_t subj_f128M_to_i32_r_near_even( const float128_t * ); +int_fast32_t subj_f128M_to_i32_r_minMag( const float128_t * ); +int_fast32_t subj_f128M_to_i32_r_min( const float128_t * ); +int_fast32_t subj_f128M_to_i32_r_max( const float128_t * ); +int_fast32_t subj_f128M_to_i32_r_near_maxMag( extFloat80_t * ); +int_fast64_t subj_f128M_to_i64_r_near_even( const float128_t * ); +int_fast64_t subj_f128M_to_i64_r_minMag( const float128_t * ); +int_fast64_t subj_f128M_to_i64_r_min( const float128_t * ); +int_fast64_t subj_f128M_to_i64_r_max( const float128_t * ); +int_fast64_t subj_f128M_to_i64_r_near_maxMag( extFloat80_t * ); + +uint_fast32_t subj_f128M_to_ui32_rx_near_even( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_rx_minMag( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_rx_min( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_rx_max( const float128_t * ); +uint_fast32_t subj_f128M_to_ui32_rx_near_maxMag( extFloat80_t * ); +uint_fast64_t subj_f128M_to_ui64_rx_near_even( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_rx_minMag( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_rx_min( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_rx_max( const float128_t * ); +uint_fast64_t subj_f128M_to_ui64_rx_near_maxMag( extFloat80_t * ); +int_fast32_t subj_f128M_to_i32_rx_near_even( const float128_t * ); +int_fast32_t subj_f128M_to_i32_rx_minMag( const float128_t * ); +int_fast32_t subj_f128M_to_i32_rx_min( const float128_t * ); +int_fast32_t subj_f128M_to_i32_rx_max( const float128_t * ); +int_fast32_t subj_f128M_to_i32_rx_near_maxMag( extFloat80_t * ); +int_fast64_t subj_f128M_to_i64_rx_near_even( const float128_t * ); +int_fast64_t subj_f128M_to_i64_rx_minMag( const float128_t * ); +int_fast64_t subj_f128M_to_i64_rx_min( const float128_t * ); +int_fast64_t subj_f128M_to_i64_rx_max( const float128_t * ); +int_fast64_t subj_f128M_to_i64_rx_near_maxMag( extFloat80_t * ); + +#ifdef FLOAT16 +float16_t subj_f128M_to_f16( const float128_t * ); +#endif +float32_t subj_f128M_to_f32( const float128_t * ); +#ifdef FLOAT64 +float64_t subj_f128M_to_f64( const float128_t * ); +#endif +#ifdef FLOAT128 +void subj_f128M_to_extF80M( const float128_t *, extFloat80_t * ); +#endif + +void subj_f128M_roundToInt_r_near_even( const float128_t, float128_t * ); +void subj_f128M_roundToInt_r_minMag( const float128_t, float128_t * ); +void subj_f128M_roundToInt_r_min( const float128_t, float128_t * ); +void subj_f128M_roundToInt_r_max( const float128_t, float128_t * ); +void subj_f128M_roundToInt_r_near_maxMag( const float128_t, float128_t * ); +void subj_f128M_roundToInt_x( const float128_t, float128_t * ); +void subj_f128M_add( const float128_t *, const float128_t *, float128_t * ); +void subj_f128M_sub( const float128_t *, const float128_t *, float128_t * ); +void subj_f128M_mul( const float128_t *, const float128_t *, float128_t * ); +void + subj_f128M_mulAdd( + const float128_t *, const float128_t *, const float128_t *, float128_t * + ); +void subj_f128M_div( const float128_t *, const float128_t *, float128_t * ); +void subj_f128M_rem( const float128_t *, const float128_t *, float128_t * ); +void subj_f128M_sqrt( const float128_t *, float128_t * ); +bool subj_f128M_eq( const float128_t *, const float128_t * ); +bool subj_f128M_le( const float128_t *, const float128_t * ); +bool subj_f128M_lt( const float128_t *, const float128_t * ); +bool subj_f128M_eq_signaling( const float128_t *, const float128_t * ); +bool subj_f128M_le_quiet( const float128_t *, const float128_t * ); +bool subj_f128M_lt_quiet( const float128_t *, const float128_t * ); + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat_functions.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat_functions.c new file mode 100644 index 000000000..4d3ff6248 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/subjfloat_functions.c @@ -0,0 +1,1810 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "subjfloat_config.h" +#include "subjfloat.h" +#include "functions.h" + +typedef void genericFuncType(); + +/*---------------------------------------------------------------------------- +| WARNING: +| This file should not normally be modified. See "subjfloat_config.h" +| instead. +| The order of these array entries must match the order in the array +| `standardFunctionInfos'. Be careful about making changes. +*----------------------------------------------------------------------------*/ + +genericFuncType *const subjfloat_functions[] = { + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 +#ifdef SUBJ_UI32_TO_F16 + (genericFuncType *) subj_ui32_to_f16, +#else + 0, +#endif +#endif +#ifdef SUBJ_UI32_TO_F32 + (genericFuncType *) subj_ui32_to_f32, +#else + 0, +#endif +#ifdef FLOAT64 +#ifdef SUBJ_UI32_TO_F64 + (genericFuncType *) subj_ui32_to_f64, +#else + 0, +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_UI32_TO_EXTF80 + (genericFuncType *) subj_ui32_to_extF80M, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_UI32_TO_F128 + (genericFuncType *) subj_ui32_to_f128M, +#else + 0, +#endif +#endif +#ifdef FLOAT16 +#ifdef SUBJ_UI64_TO_F16 + (genericFuncType *) subj_ui64_to_f16, +#else + 0, +#endif +#endif +#ifdef SUBJ_UI64_TO_F32 + (genericFuncType *) subj_ui64_to_f32, +#else + 0, +#endif +#ifdef FLOAT64 +#ifdef SUBJ_UI64_TO_F64 + (genericFuncType *) subj_ui64_to_f64, +#else + 0, +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_UI64_TO_EXTF80 + (genericFuncType *) subj_ui64_to_extF80M, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_UI64_TO_F128 + (genericFuncType *) subj_ui64_to_f128M, +#else + 0, +#endif +#endif +#ifdef FLOAT16 +#ifdef SUBJ_I32_TO_F16 + (genericFuncType *) subj_i32_to_f16, +#else + 0, +#endif +#endif +#ifdef SUBJ_I32_TO_F32 + (genericFuncType *) subj_i32_to_f32, +#else + 0, +#endif +#ifdef FLOAT64 +#ifdef SUBJ_I32_TO_F64 + (genericFuncType *) subj_i32_to_f64, +#else + 0, +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_I32_TO_EXTF80 + (genericFuncType *) subj_i32_to_extF80M, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_I32_TO_F128 + (genericFuncType *) subj_i32_to_f128M, +#else + 0, +#endif +#endif +#ifdef FLOAT16 +#ifdef SUBJ_I64_TO_F16 + (genericFuncType *) subj_i64_to_f16, +#else + 0, +#endif +#endif +#ifdef SUBJ_I64_TO_F32 + (genericFuncType *) subj_i64_to_f32, +#else + 0, +#endif +#ifdef FLOAT64 +#ifdef SUBJ_I64_TO_F64 + (genericFuncType *) subj_i64_to_f64, +#else + 0, +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_I64_TO_EXTF80 + (genericFuncType *) subj_i64_to_extF80M, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_I64_TO_F128 + (genericFuncType *) subj_i64_to_f128M, +#else + 0, +#endif +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT16 +#ifdef SUBJ_F16_TO_UI32_R_NEAR_EVEN + (genericFuncType *) subj_f16_to_ui32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_R_MINMAG + (genericFuncType *) subj_f16_to_ui32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_R_MIN + (genericFuncType *) subj_f16_to_ui32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_R_MAX + (genericFuncType *) subj_f16_to_ui32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_R_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_ui32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_R_NEAR_EVEN + (genericFuncType *) subj_f16_to_ui64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_R_MINMAG + (genericFuncType *) subj_f16_to_ui64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_R_MIN + (genericFuncType *) subj_f16_to_ui64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_R_MAX + (genericFuncType *) subj_f16_to_ui64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_R_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_ui64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_R_NEAR_EVEN + (genericFuncType *) subj_f16_to_i32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_R_MINMAG + (genericFuncType *) subj_f16_to_i32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_R_MIN + (genericFuncType *) subj_f16_to_i32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_R_MAX + (genericFuncType *) subj_f16_to_i32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_R_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_i32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_R_NEAR_EVEN + (genericFuncType *) subj_f16_to_i64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_R_MINMAG + (genericFuncType *) subj_f16_to_i64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_R_MIN + (genericFuncType *) subj_f16_to_i64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_R_MAX + (genericFuncType *) subj_f16_to_i64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_R_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_i64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_RX_NEAR_EVEN + (genericFuncType *) subj_f16_to_ui32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_RX_MINMAG + (genericFuncType *) subj_f16_to_ui32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_RX_MIN + (genericFuncType *) subj_f16_to_ui32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_RX_MAX + (genericFuncType *) subj_f16_to_ui32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_ui32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_RX_NEAR_EVEN + (genericFuncType *) subj_f16_to_ui64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_RX_MINMAG + (genericFuncType *) subj_f16_to_ui64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_RX_MIN + (genericFuncType *) subj_f16_to_ui64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_RX_MAX + (genericFuncType *) subj_f16_to_ui64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_UI64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_ui64_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_RX_NEAR_EVEN + (genericFuncType *) subj_f16_to_i32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_RX_MINMAG + (genericFuncType *) subj_f16_to_i32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_RX_MIN + (genericFuncType *) subj_f16_to_i32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_RX_MAX + (genericFuncType *) subj_f16_to_i32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_i32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_RX_NEAR_EVEN + (genericFuncType *) subj_f16_to_i64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_RX_MINMAG + (genericFuncType *) subj_f16_to_i64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_RX_MIN + (genericFuncType *) subj_f16_to_i64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_RX_MAX + (genericFuncType *) subj_f16_to_i64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_I64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f16_to_i64_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_TO_F32 + (genericFuncType *) subj_f16_to_f32, +#else + 0, +#endif +#ifdef FLOAT64 +#ifdef SUBJ_F16_TO_F64 + (genericFuncType *) subj_f16_to_f64, +#else + 0, +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F16_TO_EXTF80 + (genericFuncType *) subj_f16_to_extF80M, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_F16_TO_F128 + (genericFuncType *) subj_f16_to_f128M, +#else + 0, +#endif +#endif +#ifdef SUBJ_F16_ROUNDTOINT_R_NEAR_EVEN + (genericFuncType *) subj_f16_roundToInt_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F16_ROUNDTOINT_R_MINMAG + (genericFuncType *) subj_f16_roundToInt_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F16_ROUNDTOINT_R_MIN + (genericFuncType *) subj_f16_roundToInt_r_min, +#else + 0, +#endif +#ifdef SUBJ_F16_ROUNDTOINT_R_MAX + (genericFuncType *) subj_f16_roundToInt_r_max, +#else + 0, +#endif +#ifdef SUBJ_F16_ROUNDTOINT_R_NEAR_MAXMAG + (genericFuncType *) subj_f16_roundToInt_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F16_ROUNDTOINT_X + (genericFuncType *) subj_f16_roundToInt_x, +#else + 0, +#endif +#ifdef SUBJ_F16_ADD + (genericFuncType *) subj_f16_add, +#else + 0, +#endif +#ifdef SUBJ_F16_SUB + (genericFuncType *) subj_f16_sub, +#else + 0, +#endif +#ifdef SUBJ_F16_MUL + (genericFuncType *) subj_f16_mul, +#else + 0, +#endif +#ifdef SUBJ_F16_MULADD + (genericFuncType *) subj_f16_mulAdd, +#else + 0, +#endif +#ifdef SUBJ_F16_DIV + (genericFuncType *) subj_f16_div, +#else + 0, +#endif +#ifdef SUBJ_F16_REM + (genericFuncType *) subj_f16_rem, +#else + 0, +#endif +#ifdef SUBJ_F16_SQRT + (genericFuncType *) subj_f16_sqrt, +#else + 0, +#endif +#ifdef SUBJ_F16_EQ + (genericFuncType *) subj_f16_eq, +#else + 0, +#endif +#ifdef SUBJ_F16_LE + (genericFuncType *) subj_f16_le, +#else + 0, +#endif +#ifdef SUBJ_F16_LT + (genericFuncType *) subj_f16_lt, +#else + 0, +#endif +#ifdef SUBJ_F16_EQ_SIGNALING + (genericFuncType *) subj_f16_eq_signaling, +#else + 0, +#endif +#ifdef SUBJ_F16_LE_QUIET + (genericFuncType *) subj_f16_le_quiet, +#else + 0, +#endif +#ifdef SUBJ_F16_LT_QUIET + (genericFuncType *) subj_f16_lt_quiet, +#else + 0, +#endif +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef SUBJ_F32_TO_UI32_R_NEAR_EVEN + (genericFuncType *) subj_f32_to_ui32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_R_MINMAG + (genericFuncType *) subj_f32_to_ui32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_R_MIN + (genericFuncType *) subj_f32_to_ui32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_R_MAX + (genericFuncType *) subj_f32_to_ui32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_R_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_ui32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_R_NEAR_EVEN + (genericFuncType *) subj_f32_to_ui64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_R_MINMAG + (genericFuncType *) subj_f32_to_ui64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_R_MIN + (genericFuncType *) subj_f32_to_ui64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_R_MAX + (genericFuncType *) subj_f32_to_ui64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_R_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_ui64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_R_NEAR_EVEN + (genericFuncType *) subj_f32_to_i32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_R_MINMAG + (genericFuncType *) subj_f32_to_i32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_R_MIN + (genericFuncType *) subj_f32_to_i32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_R_MAX + (genericFuncType *) subj_f32_to_i32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_R_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_i32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_R_NEAR_EVEN + (genericFuncType *) subj_f32_to_i64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_R_MINMAG + (genericFuncType *) subj_f32_to_i64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_R_MIN + (genericFuncType *) subj_f32_to_i64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_R_MAX + (genericFuncType *) subj_f32_to_i64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_R_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_i64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_RX_NEAR_EVEN + (genericFuncType *) subj_f32_to_ui32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_RX_MINMAG + (genericFuncType *) subj_f32_to_ui32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_RX_MIN + (genericFuncType *) subj_f32_to_ui32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_RX_MAX + (genericFuncType *) subj_f32_to_ui32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_ui32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_RX_NEAR_EVEN + (genericFuncType *) subj_f32_to_ui64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_RX_MINMAG + (genericFuncType *) subj_f32_to_ui64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_RX_MIN + (genericFuncType *) subj_f32_to_ui64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_RX_MAX + (genericFuncType *) subj_f32_to_ui64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_UI64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_ui64_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_RX_NEAR_EVEN + (genericFuncType *) subj_f32_to_i32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_RX_MINMAG + (genericFuncType *) subj_f32_to_i32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_RX_MIN + (genericFuncType *) subj_f32_to_i32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_RX_MAX + (genericFuncType *) subj_f32_to_i32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_i32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_RX_NEAR_EVEN + (genericFuncType *) subj_f32_to_i64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_RX_MINMAG + (genericFuncType *) subj_f32_to_i64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_RX_MIN + (genericFuncType *) subj_f32_to_i64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_RX_MAX + (genericFuncType *) subj_f32_to_i64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F32_TO_I64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f32_to_i64_rx_near_maxMag, +#else + 0, +#endif +#ifdef FLOAT16 +#ifdef SUBJ_F32_TO_F16 + (genericFuncType *) subj_f32_to_f16, +#else + 0, +#endif +#endif +#ifdef FLOAT64 +#ifdef SUBJ_F32_TO_F64 + (genericFuncType *) subj_f32_to_f64, +#else + 0, +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F32_TO_EXTF80 + (genericFuncType *) subj_f32_to_extF80M, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_F32_TO_F128 + (genericFuncType *) subj_f32_to_f128M, +#else + 0, +#endif +#endif +#ifdef SUBJ_F32_ROUNDTOINT_R_NEAR_EVEN + (genericFuncType *) subj_f32_roundToInt_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F32_ROUNDTOINT_R_MINMAG + (genericFuncType *) subj_f32_roundToInt_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F32_ROUNDTOINT_R_MIN + (genericFuncType *) subj_f32_roundToInt_r_min, +#else + 0, +#endif +#ifdef SUBJ_F32_ROUNDTOINT_R_MAX + (genericFuncType *) subj_f32_roundToInt_r_max, +#else + 0, +#endif +#ifdef SUBJ_F32_ROUNDTOINT_R_NEAR_MAXMAG + (genericFuncType *) subj_f32_roundToInt_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F32_ROUNDTOINT_X + (genericFuncType *) subj_f32_roundToInt_x, +#else + 0, +#endif +#ifdef SUBJ_F32_ADD + (genericFuncType *) subj_f32_add, +#else + 0, +#endif +#ifdef SUBJ_F32_SUB + (genericFuncType *) subj_f32_sub, +#else + 0, +#endif +#ifdef SUBJ_F32_MUL + (genericFuncType *) subj_f32_mul, +#else + 0, +#endif +#ifdef SUBJ_F32_MULADD + (genericFuncType *) subj_f32_mulAdd, +#else + 0, +#endif +#ifdef SUBJ_F32_DIV + (genericFuncType *) subj_f32_div, +#else + 0, +#endif +#ifdef SUBJ_F32_REM + (genericFuncType *) subj_f32_rem, +#else + 0, +#endif +#ifdef SUBJ_F32_SQRT + (genericFuncType *) subj_f32_sqrt, +#else + 0, +#endif +#ifdef SUBJ_F32_EQ + (genericFuncType *) subj_f32_eq, +#else + 0, +#endif +#ifdef SUBJ_F32_LE + (genericFuncType *) subj_f32_le, +#else + 0, +#endif +#ifdef SUBJ_F32_LT + (genericFuncType *) subj_f32_lt, +#else + 0, +#endif +#ifdef SUBJ_F32_EQ_SIGNALING + (genericFuncType *) subj_f32_eq_signaling, +#else + 0, +#endif +#ifdef SUBJ_F32_LE_QUIET + (genericFuncType *) subj_f32_le_quiet, +#else + 0, +#endif +#ifdef SUBJ_F32_LT_QUIET + (genericFuncType *) subj_f32_lt_quiet, +#else + 0, +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT64 +#ifdef SUBJ_F64_TO_UI32_R_NEAR_EVEN + (genericFuncType *) subj_f64_to_ui32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_R_MINMAG + (genericFuncType *) subj_f64_to_ui32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_R_MIN + (genericFuncType *) subj_f64_to_ui32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_R_MAX + (genericFuncType *) subj_f64_to_ui32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_R_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_ui32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_R_NEAR_EVEN + (genericFuncType *) subj_f64_to_ui64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_R_MINMAG + (genericFuncType *) subj_f64_to_ui64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_R_MIN + (genericFuncType *) subj_f64_to_ui64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_R_MAX + (genericFuncType *) subj_f64_to_ui64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_R_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_ui64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_R_NEAR_EVEN + (genericFuncType *) subj_f64_to_i32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_R_MINMAG + (genericFuncType *) subj_f64_to_i32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_R_MIN + (genericFuncType *) subj_f64_to_i32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_R_MAX + (genericFuncType *) subj_f64_to_i32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_R_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_i32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_R_NEAR_EVEN + (genericFuncType *) subj_f64_to_i64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_R_MINMAG + (genericFuncType *) subj_f64_to_i64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_R_MIN + (genericFuncType *) subj_f64_to_i64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_R_MAX + (genericFuncType *) subj_f64_to_i64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_R_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_i64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_RX_NEAR_EVEN + (genericFuncType *) subj_f64_to_ui32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_RX_MINMAG + (genericFuncType *) subj_f64_to_ui32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_RX_MIN + (genericFuncType *) subj_f64_to_ui32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_RX_MAX + (genericFuncType *) subj_f64_to_ui32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_ui32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_RX_NEAR_EVEN + (genericFuncType *) subj_f64_to_ui64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_RX_MINMAG + (genericFuncType *) subj_f64_to_ui64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_RX_MIN + (genericFuncType *) subj_f64_to_ui64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_RX_MAX + (genericFuncType *) subj_f64_to_ui64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_UI64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_ui64_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_RX_NEAR_EVEN + (genericFuncType *) subj_f64_to_i32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_RX_MINMAG + (genericFuncType *) subj_f64_to_i32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_RX_MIN + (genericFuncType *) subj_f64_to_i32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_RX_MAX + (genericFuncType *) subj_f64_to_i32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_i32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_RX_NEAR_EVEN + (genericFuncType *) subj_f64_to_i64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_RX_MINMAG + (genericFuncType *) subj_f64_to_i64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_RX_MIN + (genericFuncType *) subj_f64_to_i64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_RX_MAX + (genericFuncType *) subj_f64_to_i64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F64_TO_I64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f64_to_i64_rx_near_maxMag, +#else + 0, +#endif +#ifdef FLOAT16 +#ifdef SUBJ_F64_TO_F16 + (genericFuncType *) subj_f64_to_f16, +#else + 0, +#endif +#endif +#ifdef SUBJ_F64_TO_F32 + (genericFuncType *) subj_f64_to_f32, +#else + 0, +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F64_TO_EXTF80 + (genericFuncType *) subj_f64_to_extF80M, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_F64_TO_F128 + (genericFuncType *) subj_f64_to_f128M, +#else + 0, +#endif +#endif +#ifdef SUBJ_F64_ROUNDTOINT_R_NEAR_EVEN + (genericFuncType *) subj_f64_roundToInt_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F64_ROUNDTOINT_R_MINMAG + (genericFuncType *) subj_f64_roundToInt_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F64_ROUNDTOINT_R_MIN + (genericFuncType *) subj_f64_roundToInt_r_min, +#else + 0, +#endif +#ifdef SUBJ_F64_ROUNDTOINT_R_MAX + (genericFuncType *) subj_f64_roundToInt_r_max, +#else + 0, +#endif +#ifdef SUBJ_F64_ROUNDTOINT_R_NEAR_MAXMAG + (genericFuncType *) subj_f64_roundToInt_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F64_ROUNDTOINT_X + (genericFuncType *) subj_f64_roundToInt_x, +#else + 0, +#endif +#ifdef SUBJ_F64_ADD + (genericFuncType *) subj_f64_add, +#else + 0, +#endif +#ifdef SUBJ_F64_SUB + (genericFuncType *) subj_f64_sub, +#else + 0, +#endif +#ifdef SUBJ_F64_MUL + (genericFuncType *) subj_f64_mul, +#else + 0, +#endif +#ifdef SUBJ_F64_MULADD + (genericFuncType *) subj_f64_mulAdd, +#else + 0, +#endif +#ifdef SUBJ_F64_DIV + (genericFuncType *) subj_f64_div, +#else + 0, +#endif +#ifdef SUBJ_F64_REM + (genericFuncType *) subj_f64_rem, +#else + 0, +#endif +#ifdef SUBJ_F64_SQRT + (genericFuncType *) subj_f64_sqrt, +#else + 0, +#endif +#ifdef SUBJ_F64_EQ + (genericFuncType *) subj_f64_eq, +#else + 0, +#endif +#ifdef SUBJ_F64_LE + (genericFuncType *) subj_f64_le, +#else + 0, +#endif +#ifdef SUBJ_F64_LT + (genericFuncType *) subj_f64_lt, +#else + 0, +#endif +#ifdef SUBJ_F64_EQ_SIGNALING + (genericFuncType *) subj_f64_eq_signaling, +#else + 0, +#endif +#ifdef SUBJ_F64_LE_QUIET + (genericFuncType *) subj_f64_le_quiet, +#else + 0, +#endif +#ifdef SUBJ_F64_LT_QUIET + (genericFuncType *) subj_f64_lt_quiet, +#else + 0, +#endif +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef EXTFLOAT80 +#ifdef SUBJ_EXTF80_TO_UI32_R_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_ui32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_R_MINMAG + (genericFuncType *) subj_extF80M_to_ui32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_R_MIN + (genericFuncType *) subj_extF80M_to_ui32_r_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_R_MAX + (genericFuncType *) subj_extF80M_to_ui32_r_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_R_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_ui32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_R_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_ui64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_R_MINMAG + (genericFuncType *) subj_extF80M_to_ui64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_R_MIN + (genericFuncType *) subj_extF80M_to_ui64_r_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_R_MAX + (genericFuncType *) subj_extF80M_to_ui64_r_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_R_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_ui64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_R_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_i32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_R_MINMAG + (genericFuncType *) subj_extF80M_to_i32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_R_MIN + (genericFuncType *) subj_extF80M_to_i32_r_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_R_MAX + (genericFuncType *) subj_extF80M_to_i32_r_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_R_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_i32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_R_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_i64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_R_MINMAG + (genericFuncType *) subj_extF80M_to_i64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_R_MIN + (genericFuncType *) subj_extF80M_to_i64_r_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_R_MAX + (genericFuncType *) subj_extF80M_to_i64_r_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_R_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_i64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_RX_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_ui32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_RX_MINMAG + (genericFuncType *) subj_extF80M_to_ui32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_RX_MIN + (genericFuncType *) subj_extF80M_to_ui32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_RX_MAX + (genericFuncType *) subj_extF80M_to_ui32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI32_RX_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_ui32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_RX_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_ui64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_RX_MINMAG + (genericFuncType *) subj_extF80M_to_ui64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_RX_MIN + (genericFuncType *) subj_extF80M_to_ui64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_RX_MAX + (genericFuncType *) subj_extF80M_to_ui64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_UI64_RX_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_ui64_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_RX_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_i32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_RX_MINMAG + (genericFuncType *) subj_extF80M_to_i32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_RX_MIN + (genericFuncType *) subj_extF80M_to_i32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_RX_MAX + (genericFuncType *) subj_extF80M_to_i32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I32_RX_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_i32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_RX_NEAR_EVEN + (genericFuncType *) subj_extF80M_to_i64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_RX_MINMAG + (genericFuncType *) subj_extF80M_to_i64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_RX_MIN + (genericFuncType *) subj_extF80M_to_i64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_RX_MAX + (genericFuncType *) subj_extF80M_to_i64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_TO_I64_RX_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_to_i64_rx_near_maxMag, +#else + 0, +#endif +#ifdef FLOAT16 +#ifdef SUBJ_EXTF80_TO_F16 + (genericFuncType *) subj_extF80M_to_f16, +#else + 0, +#endif +#endif +#ifdef SUBJ_EXTF80_TO_F32 + (genericFuncType *) subj_extF80M_to_f32, +#else + 0, +#endif +#ifdef FLOAT64 +#ifdef SUBJ_EXTF80_TO_F64 + (genericFuncType *) subj_extF80M_to_f64, +#else + 0, +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_EXTF80_TO_F128 + (genericFuncType *) subj_extF80M_to_f128M, +#else + 0, +#endif +#endif +#ifdef SUBJ_EXTF80_ROUNDTOINT_R_NEAR_EVEN + (genericFuncType *) subj_extF80M_roundToInt_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_ROUNDTOINT_R_MINMAG + (genericFuncType *) subj_extF80M_roundToInt_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_ROUNDTOINT_R_MIN + (genericFuncType *) subj_extF80M_roundToInt_r_min, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_ROUNDTOINT_R_MAX + (genericFuncType *) subj_extF80M_roundToInt_r_max, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_ROUNDTOINT_R_NEAR_MAXMAG + (genericFuncType *) subj_extF80M_roundToInt_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_ROUNDTOINT_X + (genericFuncType *) subj_extF80M_roundToInt_x, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_ADD + (genericFuncType *) subj_extF80M_add, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_SUB + (genericFuncType *) subj_extF80M_sub, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_MUL + (genericFuncType *) subj_extF80M_mul, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_DIV + (genericFuncType *) subj_extF80M_div, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_REM + (genericFuncType *) subj_extF80M_rem, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_SQRT + (genericFuncType *) subj_extF80M_sqrt, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_EQ + (genericFuncType *) subj_extF80M_eq, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_LE + (genericFuncType *) subj_extF80M_le, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_LT + (genericFuncType *) subj_extF80M_lt, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_EQ_SIGNALING + (genericFuncType *) subj_extF80M_eq_signaling, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_LE_QUIET + (genericFuncType *) subj_extF80M_le_quiet, +#else + 0, +#endif +#ifdef SUBJ_EXTF80_LT_QUIET + (genericFuncType *) subj_extF80M_lt_quiet, +#else + 0, +#endif +#endif + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ +#ifdef FLOAT128 +#ifdef SUBJ_F128_TO_UI32_R_NEAR_EVEN + (genericFuncType *) subj_f128M_to_ui32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_R_MINMAG + (genericFuncType *) subj_f128M_to_ui32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_R_MIN + (genericFuncType *) subj_f128M_to_ui32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_R_MAX + (genericFuncType *) subj_f128M_to_ui32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_R_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_ui32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_R_NEAR_EVEN + (genericFuncType *) subj_f128M_to_ui64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_R_MINMAG + (genericFuncType *) subj_f128M_to_ui64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_R_MIN + (genericFuncType *) subj_f128M_to_ui64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_R_MAX + (genericFuncType *) subj_f128M_to_ui64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_R_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_ui64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_R_NEAR_EVEN + (genericFuncType *) subj_f128M_to_i32_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_R_MINMAG + (genericFuncType *) subj_f128M_to_i32_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_R_MIN + (genericFuncType *) subj_f128M_to_i32_r_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_R_MAX + (genericFuncType *) subj_f128M_to_i32_r_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_R_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_i32_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_R_NEAR_EVEN + (genericFuncType *) subj_f128M_to_i64_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_R_MINMAG + (genericFuncType *) subj_f128M_to_i64_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_R_MIN + (genericFuncType *) subj_f128M_to_i64_r_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_R_MAX + (genericFuncType *) subj_f128M_to_i64_r_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_R_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_i64_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_RX_NEAR_EVEN + (genericFuncType *) subj_f128M_to_ui32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_RX_MINMAG + (genericFuncType *) subj_f128M_to_ui32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_RX_MIN + (genericFuncType *) subj_f128M_to_ui32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_RX_MAX + (genericFuncType *) subj_f128M_to_ui32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_ui32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_RX_NEAR_EVEN + (genericFuncType *) subj_f128M_to_ui64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_RX_MINMAG + (genericFuncType *) subj_f128M_to_ui64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_RX_MIN + (genericFuncType *) subj_f128M_to_ui64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_RX_MAX + (genericFuncType *) subj_f128M_to_ui64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_UI64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_ui64_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_RX_NEAR_EVEN + (genericFuncType *) subj_f128M_to_i32_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_RX_MINMAG + (genericFuncType *) subj_f128M_to_i32_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_RX_MIN + (genericFuncType *) subj_f128M_to_i32_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_RX_MAX + (genericFuncType *) subj_f128M_to_i32_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I32_RX_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_i32_rx_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_RX_NEAR_EVEN + (genericFuncType *) subj_f128M_to_i64_rx_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_RX_MINMAG + (genericFuncType *) subj_f128M_to_i64_rx_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_RX_MIN + (genericFuncType *) subj_f128M_to_i64_rx_min, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_RX_MAX + (genericFuncType *) subj_f128M_to_i64_rx_max, +#else + 0, +#endif +#ifdef SUBJ_F128_TO_I64_RX_NEAR_MAXMAG + (genericFuncType *) subj_f128M_to_i64_rx_near_maxMag, +#else + 0, +#endif +#ifdef FLOAT16 +#ifdef SUBJ_F128_TO_F16 + (genericFuncType *) subj_f128M_to_f16, +#else + 0, +#endif +#endif +#ifdef SUBJ_F128_TO_F32 + (genericFuncType *) subj_f128M_to_f32, +#else + 0, +#endif +#ifdef FLOAT64 +#ifdef SUBJ_F128_TO_F64 + (genericFuncType *) subj_f128M_to_f64, +#else + 0, +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F128_TO_EXTF80 + (genericFuncType *) subj_f128M_to_extF80M, +#else + 0, +#endif +#endif +#ifdef SUBJ_F128_ROUNDTOINT_R_NEAR_EVEN + (genericFuncType *) subj_f128M_roundToInt_r_near_even, +#else + 0, +#endif +#ifdef SUBJ_F128_ROUNDTOINT_R_MINMAG + (genericFuncType *) subj_f128M_roundToInt_r_minMag, +#else + 0, +#endif +#ifdef SUBJ_F128_ROUNDTOINT_R_MIN + (genericFuncType *) subj_f128M_roundToInt_r_min, +#else + 0, +#endif +#ifdef SUBJ_F128_ROUNDTOINT_R_MAX + (genericFuncType *) subj_f128M_roundToInt_r_max, +#else + 0, +#endif +#ifdef SUBJ_F128_ROUNDTOINT_R_NEAR_MAXMAG + (genericFuncType *) subj_f128M_roundToInt_r_near_maxMag, +#else + 0, +#endif +#ifdef SUBJ_F128_ROUNDTOINT_X + (genericFuncType *) subj_f128M_roundToInt_x, +#else + 0, +#endif +#ifdef SUBJ_F128_ADD + (genericFuncType *) subj_f128M_add, +#else + 0, +#endif +#ifdef SUBJ_F128_SUB + (genericFuncType *) subj_f128M_sub, +#else + 0, +#endif +#ifdef SUBJ_F128_MUL + (genericFuncType *) subj_f128M_mul, +#else + 0, +#endif +#ifdef SUBJ_F128_MULADD + (genericFuncType *) subj_f128M_mulAdd, +#else + 0, +#endif +#ifdef SUBJ_F128_DIV + (genericFuncType *) subj_f128M_div, +#else + 0, +#endif +#ifdef SUBJ_F128_REM + (genericFuncType *) subj_f128M_rem, +#else + 0, +#endif +#ifdef SUBJ_F128_SQRT + (genericFuncType *) subj_f128M_sqrt, +#else + 0, +#endif +#ifdef SUBJ_F128_EQ + (genericFuncType *) subj_f128M_eq, +#else + 0, +#endif +#ifdef SUBJ_F128_LE + (genericFuncType *) subj_f128M_le, +#else + 0, +#endif +#ifdef SUBJ_F128_LT + (genericFuncType *) subj_f128M_lt, +#else + 0, +#endif +#ifdef SUBJ_F128_EQ_SIGNALING + (genericFuncType *) subj_f128M_eq_signaling, +#else + 0, +#endif +#ifdef SUBJ_F128_LE_QUIET + (genericFuncType *) subj_f128M_le_quiet, +#else + 0, +#endif +#ifdef SUBJ_F128_LT_QUIET + (genericFuncType *) subj_f128M_lt_quiet, +#else + 0, +#endif +#endif +}; + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops.h b/wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops.h new file mode 100644 index 000000000..e198eaefb --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops.h @@ -0,0 +1,578 @@ + +/*============================================================================ + +This C header file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include +#include "softfloat.h" + +extern bool testLoops_forever; + +extern uint_fast8_t *testLoops_trueFlagsPtr; +extern uint_fast8_t (*testLoops_subjFlagsFunction)( void ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT16 +void test_a_ui32_z_f16( float16_t ( uint32_t ), float16_t ( uint32_t ) ); +#endif +void test_a_ui32_z_f32( float32_t ( uint32_t ), float32_t ( uint32_t ) ); +#ifdef FLOAT64 +void test_a_ui32_z_f64( float64_t ( uint32_t ), float64_t ( uint32_t ) ); +#endif +#ifdef EXTFLOAT80 +void + test_a_ui32_z_extF80( + void ( uint32_t, extFloat80_t * ), void ( uint32_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_ui32_z_f128( + void ( uint32_t, float128_t * ), void ( uint32_t, float128_t * ) + ); +#endif +#ifdef FLOAT16 +void test_a_ui64_z_f16( float16_t ( uint64_t ), float16_t ( uint64_t ) ); +#endif +void test_a_ui64_z_f32( float32_t ( uint64_t ), float32_t ( uint64_t ) ); +#ifdef FLOAT64 +void test_a_ui64_z_f64( float64_t ( uint64_t ), float64_t ( uint64_t ) ); +#endif +#ifdef EXTFLOAT80 +void + test_a_ui64_z_extF80( + void ( uint64_t, extFloat80_t * ), void ( uint64_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_ui64_z_f128( + void ( uint64_t, float128_t * ), void ( uint64_t, float128_t * ) ); +#endif +#ifdef FLOAT16 +void test_a_i32_z_f16( float16_t ( int32_t ), float16_t ( int32_t ) ); +#endif +void test_a_i32_z_f32( float32_t ( int32_t ), float32_t ( int32_t ) ); +#ifdef FLOAT64 +void test_a_i32_z_f64( float64_t ( int32_t ), float64_t ( int32_t ) ); +#endif +#ifdef EXTFLOAT80 +void + test_a_i32_z_extF80( + void ( int32_t, extFloat80_t * ), void ( int32_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_i32_z_f128( + void ( int32_t, float128_t * ), void ( int32_t, float128_t * ) ); +#endif +#ifdef FLOAT16 +void test_a_i64_z_f16( float16_t ( int64_t ), float16_t ( int64_t ) ); +#endif +void test_a_i64_z_f32( float32_t ( int64_t ), float32_t ( int64_t ) ); +#ifdef FLOAT64 +void test_a_i64_z_f64( float64_t ( int64_t ), float64_t ( int64_t ) ); +#endif +#ifdef EXTFLOAT80 +void + test_a_i64_z_extF80( + void ( int64_t, extFloat80_t * ), void ( int64_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_i64_z_f128( + void ( int64_t, float128_t * ), void ( int64_t, float128_t * ) ); +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT16 +void + test_a_f16_z_ui32_rx( + uint_fast32_t ( float16_t, uint_fast8_t, bool ), + uint_fast32_t ( float16_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f16_z_ui64_rx( + uint_fast64_t ( float16_t, uint_fast8_t, bool ), + uint_fast64_t ( float16_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f16_z_i32_rx( + int_fast32_t ( float16_t, uint_fast8_t, bool ), + int_fast32_t ( float16_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f16_z_i64_rx( + int_fast64_t ( float16_t, uint_fast8_t, bool ), + int_fast64_t ( float16_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f16_z_ui32_x( + uint_fast32_t ( float16_t, bool ), uint_fast32_t ( float16_t, bool ), bool + ); +void + test_a_f16_z_ui64_x( + uint_fast64_t ( float16_t, bool ), uint_fast64_t ( float16_t, bool ), bool + ); +void + test_a_f16_z_i32_x( + int_fast32_t ( float16_t, bool ), int_fast32_t ( float16_t, bool ), bool + ); +void + test_a_f16_z_i64_x( + int_fast64_t ( float16_t, bool ), int_fast64_t ( float16_t, bool ), bool + ); +void test_a_f16_z_f32( float32_t ( float16_t ), float32_t ( float16_t ) ); +#ifdef FLOAT64 +void test_a_f16_z_f64( float64_t ( float16_t ), float64_t ( float16_t ) ); +#endif +#ifdef EXTFLOAT80 +void + test_a_f16_z_extF80( + void ( float16_t, extFloat80_t * ), void ( float16_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_f16_z_f128( + void ( float16_t, float128_t * ), void ( float16_t, float128_t * ) ); +#endif +void test_az_f16( float16_t ( float16_t ), float16_t ( float16_t ) ); +void + test_az_f16_rx( + float16_t ( float16_t, uint_fast8_t, bool ), + float16_t ( float16_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_abz_f16( + float16_t ( float16_t, float16_t ), float16_t ( float16_t, float16_t ) ); +void + test_abcz_f16( + float16_t ( float16_t, float16_t, float16_t ), + float16_t ( float16_t, float16_t, float16_t ) + ); +void + test_ab_f16_z_bool( + bool ( float16_t, float16_t ), bool ( float16_t, float16_t ) ); +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +void + test_a_f32_z_ui32_rx( + uint_fast32_t ( float32_t, uint_fast8_t, bool ), + uint_fast32_t ( float32_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f32_z_ui64_rx( + uint_fast64_t ( float32_t, uint_fast8_t, bool ), + uint_fast64_t ( float32_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f32_z_i32_rx( + int_fast32_t ( float32_t, uint_fast8_t, bool ), + int_fast32_t ( float32_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f32_z_i64_rx( + int_fast64_t ( float32_t, uint_fast8_t, bool ), + int_fast64_t ( float32_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f32_z_ui32_x( + uint_fast32_t ( float32_t, bool ), uint_fast32_t ( float32_t, bool ), bool + ); +void + test_a_f32_z_ui64_x( + uint_fast64_t ( float32_t, bool ), uint_fast64_t ( float32_t, bool ), bool + ); +void + test_a_f32_z_i32_x( + int_fast32_t ( float32_t, bool ), int_fast32_t ( float32_t, bool ), bool + ); +void + test_a_f32_z_i64_x( + int_fast64_t ( float32_t, bool ), int_fast64_t ( float32_t, bool ), bool + ); +#ifdef FLOAT16 +void test_a_f32_z_f16( float16_t ( float32_t ), float16_t ( float32_t ) ); +#endif +#ifdef FLOAT64 +void test_a_f32_z_f64( float64_t ( float32_t ), float64_t ( float32_t ) ); +#endif +#ifdef EXTFLOAT80 +void + test_a_f32_z_extF80( + void ( float32_t, extFloat80_t * ), void ( float32_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_f32_z_f128( + void ( float32_t, float128_t * ), void ( float32_t, float128_t * ) ); +#endif +void test_az_f32( float32_t ( float32_t ), float32_t ( float32_t ) ); +void + test_az_f32_rx( + float32_t ( float32_t, uint_fast8_t, bool ), + float32_t ( float32_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_abz_f32( + float32_t ( float32_t, float32_t ), float32_t ( float32_t, float32_t ) ); +void + test_abcz_f32( + float32_t ( float32_t, float32_t, float32_t ), + float32_t ( float32_t, float32_t, float32_t ) + ); +void + test_ab_f32_z_bool( + bool ( float32_t, float32_t ), bool ( float32_t, float32_t ) ); + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT64 +void + test_a_f64_z_ui32_rx( + uint_fast32_t ( float64_t, uint_fast8_t, bool ), + uint_fast32_t ( float64_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f64_z_ui64_rx( + uint_fast64_t ( float64_t, uint_fast8_t, bool ), + uint_fast64_t ( float64_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f64_z_i32_rx( + int_fast32_t ( float64_t, uint_fast8_t, bool ), + int_fast32_t ( float64_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f64_z_i64_rx( + int_fast64_t ( float64_t, uint_fast8_t, bool ), + int_fast64_t ( float64_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f64_z_ui32_x( + uint_fast32_t ( float64_t, bool ), uint_fast32_t ( float64_t, bool ), bool + ); +void + test_a_f64_z_ui64_x( + uint_fast64_t ( float64_t, bool ), uint_fast64_t ( float64_t, bool ), bool + ); +void + test_a_f64_z_i32_x( + int_fast32_t ( float64_t, bool ), int_fast32_t ( float64_t, bool ), bool + ); +void + test_a_f64_z_i64_x( + int_fast64_t ( float64_t, bool ), int_fast64_t ( float64_t, bool ), bool + ); +#ifdef FLOAT16 +void test_a_f64_z_f16( float16_t ( float64_t ), float16_t ( float64_t ) ); +#endif +void test_a_f64_z_f32( float32_t ( float64_t ), float32_t ( float64_t ) ); +#ifdef EXTFLOAT80 +void + test_a_f64_z_extF80( + void ( float64_t, extFloat80_t * ), void ( float64_t, extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_f64_z_f128( + void ( float64_t, float128_t * ), void ( float64_t, float128_t * ) ); +#endif +void test_az_f64( float64_t ( float64_t ), float64_t ( float64_t ) ); +void + test_az_f64_rx( + float64_t ( float64_t, uint_fast8_t, bool ), + float64_t ( float64_t, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_abz_f64( + float64_t ( float64_t, float64_t ), float64_t ( float64_t, float64_t ) ); +void + test_abcz_f64( + float64_t ( float64_t, float64_t, float64_t ), + float64_t ( float64_t, float64_t, float64_t ) + ); +void + test_ab_f64_z_bool( + bool ( float64_t, float64_t ), bool ( float64_t, float64_t ) ); +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef EXTFLOAT80 +void + test_a_extF80_z_ui32_rx( + uint_fast32_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast32_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_extF80_z_ui64_rx( + uint_fast64_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast64_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_extF80_z_i32_rx( + int_fast32_t ( const extFloat80_t *, uint_fast8_t, bool ), + int_fast32_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_extF80_z_i64_rx( + int_fast64_t ( const extFloat80_t *, uint_fast8_t, bool ), + int_fast64_t ( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_extF80_z_ui32_x( + uint_fast32_t ( const extFloat80_t *, bool ), + uint_fast32_t ( const extFloat80_t *, bool ), + bool + ); +void + test_a_extF80_z_ui64_x( + uint_fast64_t ( const extFloat80_t *, bool ), + uint_fast64_t ( const extFloat80_t *, bool ), + bool + ); +void + test_a_extF80_z_i32_x( + int_fast32_t ( const extFloat80_t *, bool ), + int_fast32_t ( const extFloat80_t *, bool ), + bool + ); +void + test_a_extF80_z_i64_x( + int_fast64_t ( const extFloat80_t *, bool ), + int_fast64_t ( const extFloat80_t *, bool ), + bool + ); +#ifdef FLOAT16 +void + test_a_extF80_z_f16( + float16_t ( const extFloat80_t * ), float16_t ( const extFloat80_t * ) ); +#endif +void + test_a_extF80_z_f32( + float32_t ( const extFloat80_t * ), float32_t ( const extFloat80_t * ) ); +#ifdef FLOAT64 +void + test_a_extF80_z_f64( + float64_t ( const extFloat80_t * ), float64_t ( const extFloat80_t * ) ); +#endif +#ifdef FLOAT128 +void + test_a_extF80_z_f128( + void ( const extFloat80_t *, float128_t * ), + void ( const extFloat80_t *, float128_t * ) + ); +#endif +void + test_az_extF80( + void ( const extFloat80_t *, extFloat80_t * ), + void ( const extFloat80_t *, extFloat80_t * ) + ); +void + test_az_extF80_rx( + void ( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ), + void ( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ), + uint_fast8_t, + bool + ); +void + test_abz_extF80( + void ( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ), + void ( const extFloat80_t *, const extFloat80_t *, extFloat80_t * ) + ); +void + test_ab_extF80_z_bool( + bool ( const extFloat80_t *, const extFloat80_t * ), + bool ( const extFloat80_t *, const extFloat80_t * ) + ); +#endif + +/*---------------------------------------------------------------------------- +*----------------------------------------------------------------------------*/ +#ifdef FLOAT128 +void + test_a_f128_z_ui32_rx( + uint_fast32_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast32_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f128_z_ui64_rx( + uint_fast64_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast64_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f128_z_i32_rx( + int_fast32_t ( const float128_t *, uint_fast8_t, bool ), + int_fast32_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f128_z_i64_rx( + int_fast64_t ( const float128_t *, uint_fast8_t, bool ), + int_fast64_t ( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t, + bool + ); +void + test_a_f128_z_ui32_x( + uint_fast32_t ( const float128_t *, bool ), + uint_fast32_t ( const float128_t *, bool ), + bool + ); +void + test_a_f128_z_ui64_x( + uint_fast64_t ( const float128_t *, bool ), + uint_fast64_t ( const float128_t *, bool ), + bool + ); +void + test_a_f128_z_i32_x( + int_fast32_t ( const float128_t *, bool ), + int_fast32_t ( const float128_t *, bool ), + bool + ); +void + test_a_f128_z_i64_x( + int_fast64_t ( const float128_t *, bool ), + int_fast64_t ( const float128_t *, bool ), + bool + ); +#ifdef FLOAT16 +void + test_a_f128_z_f16( + float16_t ( const float128_t * ), float16_t ( const float128_t * ) ); +#endif +void + test_a_f128_z_f32( + float32_t ( const float128_t * ), float32_t ( const float128_t * ) ); +#ifdef FLOAT64 +void + test_a_f128_z_f64( + float64_t ( const float128_t * ), float64_t ( const float128_t * ) ); +#endif +#ifdef EXTFLOAT80 +void + test_a_f128_z_extF80( + void ( const float128_t *, extFloat80_t * ), + void ( const float128_t *, extFloat80_t * ) + ); +#endif +void + test_az_f128( + void ( const float128_t *, float128_t * ), + void ( const float128_t *, float128_t * ) + ); +void + test_az_f128_rx( + void ( const float128_t *, uint_fast8_t, bool, float128_t * ), + void ( const float128_t *, uint_fast8_t, bool, float128_t * ), + uint_fast8_t, + bool + ); +void + test_abz_f128( + void ( const float128_t *, const float128_t *, float128_t * ), + void ( const float128_t *, const float128_t *, float128_t * ) + ); +void + test_abcz_f128( + void + ( const float128_t *, + const float128_t *, + const float128_t *, + float128_t * + ), + void + ( const float128_t *, + const float128_t *, + const float128_t *, + float128_t * + ) + ); +void + test_ab_f128_z_bool( + bool ( const float128_t *, const float128_t * ), + bool ( const float128_t *, const float128_t * ) + ); +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops_common.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops_common.c new file mode 100644 index 000000000..1553aa110 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/testLoops_common.c @@ -0,0 +1,47 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "testLoops.h" + +bool testLoops_forever = false; + +uint_fast8_t *testLoops_trueFlagsPtr; +uint_fast8_t (*testLoops_subjFlagsFunction)( void ); + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f128.c new file mode 100644 index 000000000..505ef1279 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f128.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined EXTFLOAT80 && defined FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_f128( + void trueFunction( const extFloat80_t *, float128_t * ), + void subjFunction( const extFloat80_t *, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_extF80_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && extF80M_isSignalingNaN( &genCases_extF80_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f16.c new file mode 100644 index 000000000..e6a6651d2 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f16.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT16 && defined EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_f16( + float16_t trueFunction( const extFloat80_t * ), + float16_t subjFunction( const extFloat80_t * ) + ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && extF80M_isSignalingNaN( &genCases_extF80_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f32.c new file mode 100644 index 000000000..c752515d1 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f32.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_f32( + float32_t trueFunction( const extFloat80_t * ), + float32_t subjFunction( const extFloat80_t * ) + ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && extF80M_isSignalingNaN( &genCases_extF80_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f64.c new file mode 100644 index 000000000..4d24fb194 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_f64.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT64 && defined EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_f64( + float64_t trueFunction( const extFloat80_t * ), + float64_t subjFunction( const extFloat80_t * ) + ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && extF80M_isSignalingNaN( &genCases_extF80_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, "\n\t" ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_rx.c new file mode 100644 index 000000000..fd2eea41d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_rx.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_i32_rx( + int_fast32_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + int_fast32_t subjFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! extF80M_isNaN( &genCases_extF80_a ) + || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_x.c new file mode 100644 index 000000000..2260614d6 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i32_x.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_i32_x( + int_fast32_t trueFunction( const extFloat80_t *, bool ), + int_fast32_t subjFunction( const extFloat80_t *, bool ), + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! extF80M_isNaN( &genCases_extF80_a ) + || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_rx.c new file mode 100644 index 000000000..0b99e99b4 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_rx.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_i64_rx( + int_fast64_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + int_fast64_t subjFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! extF80M_isNaN( &genCases_extF80_a ) + || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, "\n\t" ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_x.c new file mode 100644 index 000000000..9e7a5b179 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_i64_x.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_i64_x( + int_fast64_t trueFunction( const extFloat80_t *, bool ), + int_fast64_t subjFunction( const extFloat80_t *, bool ), + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! extF80M_isNaN( &genCases_extF80_a ) + || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, "\n\t" ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_rx.c new file mode 100644 index 000000000..fcc92da85 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_ui32_rx( + uint_fast32_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast32_t subjFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_x.c new file mode 100644 index 000000000..ff16f1998 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui32_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_ui32_x( + uint_fast32_t trueFunction( const extFloat80_t *, bool ), + uint_fast32_t subjFunction( const extFloat80_t *, bool ), + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_rx.c new file mode 100644 index 000000000..efab40e80 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_ui64_rx( + uint_fast64_t trueFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast64_t subjFunction( const extFloat80_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, "\n\t" ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_x.c new file mode 100644 index 000000000..1c1d04ef1 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_extF80_z_ui64_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_extF80_z_ui64_x( + uint_fast64_t trueFunction( const extFloat80_t *, bool ), + uint_fast64_t subjFunction( const extFloat80_t *, bool ), + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, "\n\t" ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_extF80.c new file mode 100644 index 000000000..1bb3e19d2 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_extF80.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined EXTFLOAT80 && defined FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_extF80( + void trueFunction( const float128_t *, extFloat80_t * ), + void subjFunction( const float128_t *, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_f128_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && f128M_isSignalingNaN( &genCases_f128_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f16.c new file mode 100644 index 000000000..eb8b3fbec --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f16.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT16 && defined FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_f16( + float16_t trueFunction( const float128_t * ), + float16_t subjFunction( const float128_t * ) + ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && f128M_isSignalingNaN( &genCases_f128_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f32.c new file mode 100644 index 000000000..7df7b1fb0 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f32.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_f32( + float32_t trueFunction( const float128_t * ), + float32_t subjFunction( const float128_t * ) + ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && f128M_isSignalingNaN( &genCases_f128_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, "\n\t" ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f64.c new file mode 100644 index 000000000..96ac1e00a --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_f64.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT64 && defined FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_f64( + float64_t trueFunction( const float128_t * ), + float64_t subjFunction( const float128_t * ) + ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && f128M_isSignalingNaN( &genCases_f128_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, "\n\t" ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_rx.c new file mode 100644 index 000000000..7aa68b9fd --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_rx.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_i32_rx( + int_fast32_t trueFunction( const float128_t *, uint_fast8_t, bool ), + int_fast32_t subjFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f128M_isNaN( &genCases_f128_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_x.c new file mode 100644 index 000000000..3f2b1cb68 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i32_x.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_i32_x( + int_fast32_t trueFunction( const float128_t *, bool ), + int_fast32_t subjFunction( const float128_t *, bool ), + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f128M_isNaN( &genCases_f128_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_rx.c new file mode 100644 index 000000000..cac33bf3c --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_rx.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_i64_rx( + int_fast64_t trueFunction( const float128_t *, uint_fast8_t, bool ), + int_fast64_t subjFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f128M_isNaN( &genCases_f128_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, "\n\t" ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_x.c new file mode 100644 index 000000000..c5004c879 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_i64_x.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_i64_x( + int_fast64_t trueFunction( const float128_t *, bool ), + int_fast64_t subjFunction( const float128_t *, bool ), + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f128M_isNaN( &genCases_f128_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, "\n\t" ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_rx.c new file mode 100644 index 000000000..e4ae8cdfa --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_ui32_rx( + uint_fast32_t trueFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast32_t subjFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_x.c new file mode 100644 index 000000000..9493f4e67 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui32_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_ui32_x( + uint_fast32_t trueFunction( const float128_t *, bool ), + uint_fast32_t subjFunction( const float128_t *, bool ), + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_rx.c new file mode 100644 index 000000000..2f336de34 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_ui64_rx( + uint_fast64_t trueFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast64_t subjFunction( const float128_t *, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, "\n\t" ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_x.c new file mode 100644 index 000000000..37f703a4b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f128_z_ui64_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f128_z_ui64_x( + uint_fast64_t trueFunction( const float128_t *, bool ), + uint_fast64_t subjFunction( const float128_t *, bool ), + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, "\n\t" ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_extF80.c new file mode 100644 index 000000000..d8f39f6fd --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_extF80.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT16 && defined EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_extF80( + void trueFunction( float16_t, extFloat80_t * ), + void subjFunction( float16_t, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_f16_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_f16_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f16_isSignalingNaN( genCases_f16_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f128.c new file mode 100644 index 000000000..433418b63 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f128.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT16 && defined FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_f128( + void trueFunction( float16_t, float128_t * ), + void subjFunction( float16_t, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_f16_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_f16_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f16_isSignalingNaN( genCases_f16_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f32.c new file mode 100644 index 000000000..8e8460787 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f32.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_f32( + float32_t trueFunction( float16_t ), float32_t subjFunction( float16_t ) ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f16_isSignalingNaN( genCases_f16_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f64.c new file mode 100644 index 000000000..bf0f343c5 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_f64.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT16 && defined FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_f64( + float64_t trueFunction( float16_t ), float64_t subjFunction( float16_t ) ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f16_isSignalingNaN( genCases_f16_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_rx.c new file mode 100644 index 000000000..c73fc7625 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_rx.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_i32_rx( + int_fast32_t trueFunction( float16_t, uint_fast8_t, bool ), + int_fast32_t subjFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f16_isNaN( genCases_f16_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_x.c new file mode 100644 index 000000000..2eaba6f2a --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i32_x.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_i32_x( + int_fast32_t trueFunction( float16_t, bool ), + int_fast32_t subjFunction( float16_t, bool ), + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f16_isNaN( genCases_f16_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_rx.c new file mode 100644 index 000000000..e31d3d380 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_rx.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_i64_rx( + int_fast64_t trueFunction( float16_t, uint_fast8_t, bool ), + int_fast64_t subjFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f16_isNaN( genCases_f16_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_x.c new file mode 100644 index 000000000..bda01182e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_i64_x.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_i64_x( + int_fast64_t trueFunction( float16_t, bool ), + int_fast64_t subjFunction( float16_t, bool ), + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f16_isNaN( genCases_f16_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_rx.c new file mode 100644 index 000000000..fc302f7b0 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_ui32_rx( + uint_fast32_t trueFunction( float16_t, uint_fast8_t, bool ), + uint_fast32_t subjFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_x.c new file mode 100644 index 000000000..3905bd39d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui32_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_ui32_x( + uint_fast32_t trueFunction( float16_t, bool ), + uint_fast32_t subjFunction( float16_t, bool ), + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_rx.c new file mode 100644 index 000000000..9b34ae9cf --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_ui64_rx( + uint_fast64_t trueFunction( float16_t, uint_fast8_t, bool ), + uint_fast64_t subjFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_x.c new file mode 100644 index 000000000..2527de482 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f16_z_ui64_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f16_z_ui64_x( + uint_fast64_t trueFunction( float16_t, bool ), + uint_fast64_t subjFunction( float16_t, bool ), + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_extF80.c new file mode 100644 index 000000000..000ade09c --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_extF80.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_extF80( + void trueFunction( float32_t, extFloat80_t * ), + void subjFunction( float32_t, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_f32_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_f32_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f32_isSignalingNaN( genCases_f32_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f128.c new file mode 100644 index 000000000..bc05438b8 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f128.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_f128( + void trueFunction( float32_t, float128_t * ), + void subjFunction( float32_t, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_f32_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_f32_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f32_isSignalingNaN( genCases_f32_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f16.c new file mode 100644 index 000000000..b89002c66 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f16.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_f16( + float16_t trueFunction( float32_t ), float16_t subjFunction( float32_t ) ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f32_isSignalingNaN( genCases_f32_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f64.c new file mode 100644 index 000000000..19267cbef --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_f64.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_f64( + float64_t trueFunction( float32_t ), float64_t subjFunction( float32_t ) ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f32_isSignalingNaN( genCases_f32_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_rx.c new file mode 100644 index 000000000..d4ff4782c --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_rx.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_i32_rx( + int_fast32_t trueFunction( float32_t, uint_fast8_t, bool ), + int_fast32_t subjFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f32_isNaN( genCases_f32_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_x.c new file mode 100644 index 000000000..4883d19c8 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i32_x.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_i32_x( + int_fast32_t trueFunction( float32_t, bool ), + int_fast32_t subjFunction( float32_t, bool ), + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f32_isNaN( genCases_f32_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_rx.c new file mode 100644 index 000000000..d3216bd8f --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_rx.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_i64_rx( + int_fast64_t trueFunction( float32_t, uint_fast8_t, bool ), + int_fast64_t subjFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f32_isNaN( genCases_f32_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_x.c new file mode 100644 index 000000000..4038135d0 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_i64_x.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_i64_x( + int_fast64_t trueFunction( float32_t, bool ), + int_fast64_t subjFunction( float32_t, bool ), + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f32_isNaN( genCases_f32_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_rx.c new file mode 100644 index 000000000..9b120a589 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_rx.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_ui32_rx( + uint_fast32_t trueFunction( float32_t, uint_fast8_t, bool ), + uint_fast32_t subjFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_x.c new file mode 100644 index 000000000..18dc88126 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui32_x.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_ui32_x( + uint_fast32_t trueFunction( float32_t, bool ), + uint_fast32_t subjFunction( float32_t, bool ), + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_rx.c new file mode 100644 index 000000000..2c792c2a1 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_rx.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_ui64_rx( + uint_fast64_t trueFunction( float32_t, uint_fast8_t, bool ), + uint_fast64_t subjFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_x.c new file mode 100644 index 000000000..7cf7c3173 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f32_z_ui64_x.c @@ -0,0 +1,98 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_f32_z_ui64_x( + uint_fast64_t trueFunction( float32_t, bool ), + uint_fast64_t subjFunction( float32_t, bool ), + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_extF80.c new file mode 100644 index 000000000..76a69acce --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_extF80.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT64 && defined EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_extF80( + void trueFunction( float64_t, extFloat80_t * ), + void subjFunction( float64_t, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_f64_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_f64_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f128.c new file mode 100644 index 000000000..b53a75e7e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f128.c @@ -0,0 +1,106 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT64 && defined FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_f128( + void trueFunction( float64_t, float128_t * ), + void subjFunction( float64_t, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_f64_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_f64_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f16.c new file mode 100644 index 000000000..9f43160b4 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f16.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#if defined FLOAT16 && defined FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_f16( + float16_t trueFunction( float64_t ), float16_t subjFunction( float64_t ) ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f32.c new file mode 100644 index 000000000..48ece56be --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_f32.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_f32( + float32_t trueFunction( float64_t ), float32_t subjFunction( float64_t ) ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_rx.c new file mode 100644 index 000000000..9c0f5ffa7 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_rx.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_i32_rx( + int_fast32_t trueFunction( float64_t, uint_fast8_t, bool ), + int_fast32_t subjFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f64_isNaN( genCases_f64_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_x.c new file mode 100644 index 000000000..5ff5dcb7a --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i32_x.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_i32_x( + int_fast32_t trueFunction( float64_t, bool ), + int_fast32_t subjFunction( float64_t, bool ), + bool exact + ) +{ + int count; + int_fast32_t trueZ; + uint_fast8_t trueFlags; + int_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0x7FFFFFFF) && (subjZ != -0x7FFFFFFF - 1) + && (! f64_isNaN( genCases_f64_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_i32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_rx.c new file mode 100644 index 000000000..ead748726 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_rx.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_i64_rx( + int_fast64_t trueFunction( float64_t, uint_fast8_t, bool ), + int_fast64_t subjFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f64_isNaN( genCases_f64_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_x.c new file mode 100644 index 000000000..03ddce529 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_i64_x.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_i64_x( + int_fast64_t trueFunction( float64_t, bool ), + int_fast64_t subjFunction( float64_t, bool ), + bool exact + ) +{ + int count; + int_fast64_t trueZ; + uint_fast8_t trueFlags; + int_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != INT64_C( 0x7FFFFFFFFFFFFFFF )) + && (subjZ != -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1) + && (! f64_isNaN( genCases_f64_a ) || (subjZ != 0))) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_i64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_rx.c new file mode 100644 index 000000000..0aecb2243 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_ui32_rx( + uint_fast32_t trueFunction( float64_t, uint_fast8_t, bool ), + uint_fast32_t subjFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_x.c new file mode 100644 index 000000000..7bf6282bc --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui32_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_ui32_x( + uint_fast32_t trueFunction( float64_t, bool ), + uint_fast32_t subjFunction( float64_t, bool ), + bool exact + ) +{ + int count; + uint_fast32_t trueZ; + uint_fast8_t trueFlags; + uint_fast32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != 0xFFFFFFFF) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_ui32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_rx.c new file mode 100644 index 000000000..48066f61e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_rx.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_ui64_rx( + uint_fast64_t trueFunction( float64_t, uint_fast8_t, bool ), + uint_fast64_t subjFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_x.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_x.c new file mode 100644 index 000000000..65cecb460 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_f64_z_ui64_x.c @@ -0,0 +1,102 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017, 2018 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_f64_z_ui64_x( + uint_fast64_t trueFunction( float64_t, bool ), + uint_fast64_t subjFunction( float64_t, bool ), + bool exact + ) +{ + int count; + uint_fast64_t trueZ; + uint_fast8_t trueFlags; + uint_fast64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkInvInts + || (trueFlags != softfloat_flag_invalid) + || (subjFlags != softfloat_flag_invalid) + || ((subjZ != UINT64_C( 0xFFFFFFFFFFFFFFFF )) && (subjZ != 0)) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, " " ); + writeCase_z_ui64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_extF80.c new file mode 100644 index 000000000..deb846e64 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_extF80.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i32_z_extF80( + void trueFunction( int32_t, extFloat80_t * ), + void subjFunction( int32_t, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_i32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_i32_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_i32_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i32( genCases_i32_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f128.c new file mode 100644 index 000000000..ffb57412e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f128.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i32_z_f128( + void trueFunction( int32_t, float128_t * ), + void subjFunction( int32_t, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_i32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_i32_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_i32_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i32( genCases_i32_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f16.c new file mode 100644 index 000000000..350d70460 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f16.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i32_z_f16( + float16_t trueFunction( int32_t ), float16_t subjFunction( int32_t ) ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_i32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_i32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_i32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i32( genCases_i32_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f32.c new file mode 100644 index 000000000..cd8118aa5 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f32.c @@ -0,0 +1,95 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_i32_z_f32( + float32_t trueFunction( int32_t ), float32_t subjFunction( int32_t ) ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_i32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_i32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_i32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i32( genCases_i32_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f64.c new file mode 100644 index 000000000..f9a2feb5e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i32_z_f64.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i32_z_f64( + float64_t trueFunction( int32_t ), float64_t subjFunction( int32_t ) ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_i32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_i32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_i32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i32( genCases_i32_a, " " ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_extF80.c new file mode 100644 index 000000000..c453ab28e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_extF80.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i64_z_extF80( + void trueFunction( int64_t, extFloat80_t * ), + void subjFunction( int64_t, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_i64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_i64_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_i64_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i64( genCases_i64_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f128.c new file mode 100644 index 000000000..b79a75533 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f128.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i64_z_f128( + void trueFunction( int64_t, float128_t * ), + void subjFunction( int64_t, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_i64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_i64_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_i64_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i64( genCases_i64_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f16.c new file mode 100644 index 000000000..0f7f4e2a7 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f16.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i64_z_f16( + float16_t trueFunction( int64_t ), float16_t subjFunction( int64_t ) ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_i64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_i64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_i64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i64( genCases_i64_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f32.c new file mode 100644 index 000000000..d5bfb0ac8 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f32.c @@ -0,0 +1,95 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_i64_z_f32( + float32_t trueFunction( int64_t ), float32_t subjFunction( int64_t ) ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_i64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_i64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_i64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i64( genCases_i64_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f64.c new file mode 100644 index 000000000..39b07e88e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_i64_z_f64.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_i64_z_f64( + float64_t trueFunction( int64_t ), float64_t subjFunction( int64_t ) ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_i64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_i64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_i64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_i64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_i64( genCases_i64_a, "\n\t" ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_extF80.c new file mode 100644 index 000000000..53d9b0861 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_extF80.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui32_z_extF80( + void trueFunction( uint32_t, extFloat80_t * ), + void subjFunction( uint32_t, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui32_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_ui32_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui32( genCases_ui32_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f128.c new file mode 100644 index 000000000..cfa43b6b0 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f128.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui32_z_f128( + void trueFunction( uint32_t, float128_t * ), + void subjFunction( uint32_t, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui32_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_ui32_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui32( genCases_ui32_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f16.c new file mode 100644 index 000000000..404d1d10e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f16.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui32_z_f16( + float16_t trueFunction( uint32_t ), float16_t subjFunction( uint32_t ) ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_ui32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_ui32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui32( genCases_ui32_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f32.c new file mode 100644 index 000000000..c9618e15a --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f32.c @@ -0,0 +1,95 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui32_z_f32( + float32_t trueFunction( uint32_t ), float32_t subjFunction( uint32_t ) ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_ui32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_ui32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui32( genCases_ui32_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f64.c new file mode 100644 index 000000000..00876b7f1 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui32_z_f64.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui32_z_f64( + float64_t trueFunction( uint32_t ), float64_t subjFunction( uint32_t ) ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_ui32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_ui32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui32( genCases_ui32_a, " " ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_extF80.c new file mode 100644 index 000000000..4e34e2002 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_extF80.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui64_z_extF80( + void trueFunction( uint64_t, extFloat80_t * ), + void subjFunction( uint64_t, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui64_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_ui64_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui64( genCases_ui64_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f128.c new file mode 100644 index 000000000..81ca81cc8 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f128.c @@ -0,0 +1,101 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui64_z_f128( + void trueFunction( uint64_t, float128_t * ), + void subjFunction( uint64_t, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( genCases_ui64_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( genCases_ui64_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui64( genCases_ui64_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f16.c new file mode 100644 index 000000000..54e68badf --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f16.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui64_z_f16( + float16_t trueFunction( uint64_t ), float16_t subjFunction( uint64_t ) ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_ui64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_ui64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui64( genCases_ui64_a, " " ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f32.c new file mode 100644 index 000000000..98a0f5020 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f32.c @@ -0,0 +1,95 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui64_z_f32( + float32_t trueFunction( uint64_t ), float32_t subjFunction( uint64_t ) ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_ui64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_ui64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui64( genCases_ui64_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f64.c new file mode 100644 index 000000000..2dc6c64a5 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_a_ui64_z_f64.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_a_ui64_z_f64( + float64_t trueFunction( uint64_t ), float64_t subjFunction( uint64_t ) ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_ui64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_ui64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_ui64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_ui64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_ui64( genCases_ui64_a, "\n\t" ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_extF80_z_bool.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_extF80_z_bool.c new file mode 100644 index 000000000..3270b4f9d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_extF80_z_bool.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_ab_extF80_z_bool( + bool trueFunction( const extFloat80_t *, const extFloat80_t * ), + bool subjFunction( const extFloat80_t *, const extFloat80_t * ) + ) +{ + int count; + bool trueZ; + uint_fast8_t trueFlags; + bool subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_extF80_a, &genCases_extF80_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_extF80_a, &genCases_extF80_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (extF80M_isSignalingNaN( &genCases_extF80_a ) + || extF80M_isSignalingNaN( &genCases_extF80_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_extF80M( + &genCases_extF80_a, &genCases_extF80_b, " " ); + writeCase_z_bool( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f128_z_bool.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f128_z_bool.c new file mode 100644 index 000000000..920420295 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f128_z_bool.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_ab_f128_z_bool( + bool trueFunction( const float128_t *, const float128_t * ), + bool subjFunction( const float128_t *, const float128_t * ) + ) +{ + int count; + bool trueZ; + uint_fast8_t trueFlags; + bool subjZ; + uint_fast8_t subjFlags; + + genCases_f128_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( &genCases_f128_a, &genCases_f128_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( &genCases_f128_a, &genCases_f128_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f128M_isSignalingNaN( &genCases_f128_a ) + || f128M_isSignalingNaN( &genCases_f128_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f128M( &genCases_f128_a, &genCases_f128_b ); + writeCase_z_bool( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f16_z_bool.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f16_z_bool.c new file mode 100644 index 000000000..712aa71e4 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f16_z_bool.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_ab_f16_z_bool( + bool trueFunction( float16_t, float16_t ), + bool subjFunction( float16_t, float16_t ) + ) +{ + int count; + bool trueZ; + uint_fast8_t trueFlags; + bool subjZ; + uint_fast8_t subjFlags; + + genCases_f16_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, genCases_f16_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, genCases_f16_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f16_isSignalingNaN( genCases_f16_a ) + || f16_isSignalingNaN( genCases_f16_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f16( genCases_f16_a, genCases_f16_b ); + writeCase_z_bool( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f32_z_bool.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f32_z_bool.c new file mode 100644 index 000000000..01919d5e9 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f32_z_bool.c @@ -0,0 +1,99 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_ab_f32_z_bool( + bool trueFunction( float32_t, float32_t ), + bool subjFunction( float32_t, float32_t ) + ) +{ + int count; + bool trueZ; + uint_fast8_t trueFlags; + bool subjZ; + uint_fast8_t subjFlags; + + genCases_f32_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, genCases_f32_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, genCases_f32_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f32_isSignalingNaN( genCases_f32_a ) + || f32_isSignalingNaN( genCases_f32_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f32( genCases_f32_a, genCases_f32_b ); + writeCase_z_bool( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f64_z_bool.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f64_z_bool.c new file mode 100644 index 000000000..599b2bf46 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_ab_f64_z_bool.c @@ -0,0 +1,103 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_ab_f64_z_bool( + bool trueFunction( float64_t, float64_t ), + bool subjFunction( float64_t, float64_t ) + ) +{ + int count; + bool trueZ; + uint_fast8_t trueFlags; + bool subjZ; + uint_fast8_t subjFlags; + + genCases_f64_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, genCases_f64_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, genCases_f64_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f64_isSignalingNaN( genCases_f64_a ) + || f64_isSignalingNaN( genCases_f64_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( (trueZ != subjZ) || (trueFlags != subjFlags) ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f64( genCases_f64_a, genCases_f64_b, " " ); + writeCase_z_bool( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f128.c new file mode 100644 index 000000000..94f5bc06c --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f128.c @@ -0,0 +1,125 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_abcz_f128( + void + trueFunction( + const float128_t *, + const float128_t *, + const float128_t *, + float128_t * + ), + void + subjFunction( + const float128_t *, + const float128_t *, + const float128_t *, + float128_t * + ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_abc_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_abc_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( + &genCases_f128_a, &genCases_f128_b, &genCases_f128_c, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( + &genCases_f128_a, &genCases_f128_b, &genCases_f128_c, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && ( f128M_isSignalingNaN( &genCases_f128_a ) + || f128M_isSignalingNaN( &genCases_f128_b ) + || f128M_isSignalingNaN( &genCases_f128_c ) + ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_abc_f128M( + &genCases_f128_a, &genCases_f128_b, &genCases_f128_c ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f16.c new file mode 100644 index 000000000..6469cb4a3 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f16.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_abcz_f16( + float16_t trueFunction( float16_t, float16_t, float16_t ), + float16_t subjFunction( float16_t, float16_t, float16_t ) + ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_abc_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_abc_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, genCases_f16_b, genCases_f16_c ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, genCases_f16_b, genCases_f16_c ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && ( f16_isSignalingNaN( genCases_f16_a ) + || f16_isSignalingNaN( genCases_f16_b ) + || f16_isSignalingNaN( genCases_f16_c ) + ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_abc_f16( + genCases_f16_a, genCases_f16_b, genCases_f16_c ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f32.c new file mode 100644 index 000000000..48ae071b2 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f32.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_abcz_f32( + float32_t trueFunction( float32_t, float32_t, float32_t ), + float32_t subjFunction( float32_t, float32_t, float32_t ) + ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_abc_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_abc_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, genCases_f32_b, genCases_f32_c ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, genCases_f32_b, genCases_f32_c ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && ( f32_isSignalingNaN( genCases_f32_a ) + || f32_isSignalingNaN( genCases_f32_b ) + || f32_isSignalingNaN( genCases_f32_c ) + ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_abc_f32( + genCases_f32_a, genCases_f32_b, genCases_f32_c ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f64.c new file mode 100644 index 000000000..36626a511 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abcz_f64.c @@ -0,0 +1,111 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_abcz_f64( + float64_t trueFunction( float64_t, float64_t, float64_t ), + float64_t subjFunction( float64_t, float64_t, float64_t ) + ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_abc_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_abc_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, genCases_f64_b, genCases_f64_c ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, genCases_f64_b, genCases_f64_c ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && ( f64_isSignalingNaN( genCases_f64_a ) + || f64_isSignalingNaN( genCases_f64_b ) + || f64_isSignalingNaN( genCases_f64_c ) + ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_abc_f64( + genCases_f64_a, genCases_f64_b, genCases_f64_c ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_extF80.c new file mode 100644 index 000000000..c4239f07d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_extF80.c @@ -0,0 +1,113 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_abz_extF80( + void + trueFunction( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ), + void + subjFunction( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, &genCases_extF80_b, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_extF80_a, &genCases_extF80_b, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (extF80M_isSignalingNaN( &genCases_extF80_a ) + || extF80M_isSignalingNaN( &genCases_extF80_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_extF80M( + &genCases_extF80_a, &genCases_extF80_b, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f128.c new file mode 100644 index 000000000..6fe68415e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f128.c @@ -0,0 +1,108 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_abz_f128( + void trueFunction( const float128_t *, const float128_t *, float128_t * ), + void subjFunction( const float128_t *, const float128_t *, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, &genCases_f128_b, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_f128_a, &genCases_f128_b, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f128M_isSignalingNaN( &genCases_f128_a ) + || f128M_isSignalingNaN( &genCases_f128_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f128M( &genCases_f128_a, &genCases_f128_b ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f16.c new file mode 100644 index 000000000..cc5e9436f --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f16.c @@ -0,0 +1,108 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_abz_f16( + float16_t trueFunction( float16_t, float16_t ), + float16_t subjFunction( float16_t, float16_t ) + ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, genCases_f16_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, genCases_f16_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f16_isSignalingNaN( genCases_f16_a ) + || f16_isSignalingNaN( genCases_f16_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f16( genCases_f16_a, genCases_f16_b ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f32.c new file mode 100644 index 000000000..cd595b6c9 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f32.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_abz_f32( + float32_t trueFunction( float32_t, float32_t ), + float32_t subjFunction( float32_t, float32_t ) + ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, genCases_f32_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, genCases_f32_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f32_isSignalingNaN( genCases_f32_a ) + || f32_isSignalingNaN( genCases_f32_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f32( genCases_f32_a, genCases_f32_b ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f64.c new file mode 100644 index 000000000..f54b90350 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_abz_f64.c @@ -0,0 +1,108 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_abz_f64( + float64_t trueFunction( float64_t, float64_t ), + float64_t subjFunction( float64_t, float64_t ) + ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_ab_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_ab_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, genCases_f64_b ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, genCases_f64_b ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && (f64_isSignalingNaN( genCases_f64_a ) + || f64_isSignalingNaN( genCases_f64_b )) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_ab_f64( genCases_f64_a, genCases_f64_b, "\n\t" ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80.c new file mode 100644 index 000000000..e1e6a4618 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_az_extF80( + void trueFunction( const extFloat80_t *, extFloat80_t * ), + void subjFunction( const extFloat80_t *, extFloat80_t * ) + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_extF80_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && extF80M_isSignalingNaN( &genCases_extF80_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80_rx.c new file mode 100644 index 000000000..91a7cbad2 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_extF80_rx.c @@ -0,0 +1,112 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef EXTFLOAT80 + +#pragma STDC FENV_ACCESS ON + +void + test_az_extF80_rx( + void + trueFunction( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ), + void + subjFunction( const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + extFloat80_t trueZ; + uint_fast8_t trueFlags; + extFloat80_t subjZ; + uint_fast8_t subjFlags; + + genCases_extF80_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_extF80_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_extF80_a, roundingMode, exact, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_extF80_a, roundingMode, exact, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! extF80M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && extF80M_isSignalingNaN( &genCases_extF80_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! extF80M_isNaN( &trueZ ) + || ! extF80M_isNaN( &subjZ ) + || extF80M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_extF80M( &genCases_extF80_a, "\n\t" ); + writeCase_z_extF80M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128.c new file mode 100644 index 000000000..f10e7415d --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128.c @@ -0,0 +1,107 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_az_f128( + void trueFunction( const float128_t *, float128_t * ), + void subjFunction( const float128_t *, float128_t * ) + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_f128_a, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && f128M_isSignalingNaN( &genCases_f128_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128_rx.c new file mode 100644 index 000000000..9c93e8a0a --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f128_rx.c @@ -0,0 +1,110 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT128 + +#pragma STDC FENV_ACCESS ON + +void + test_az_f128_rx( + void trueFunction( const float128_t *, uint_fast8_t, bool, float128_t * ), + void subjFunction( const float128_t *, uint_fast8_t, bool, float128_t * ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + float128_t trueZ; + uint_fast8_t trueFlags; + float128_t subjZ; + uint_fast8_t subjFlags; + + genCases_f128_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f128_a_next(); + *testLoops_trueFlagsPtr = 0; + trueFunction( &genCases_f128_a, roundingMode, exact, &trueZ ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjFunction( &genCases_f128_a, roundingMode, exact, &subjZ ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f128M_same( &trueZ, &subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs + && f128M_isSignalingNaN( &genCases_f128_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f128M_isNaN( &trueZ ) + || ! f128M_isNaN( &subjZ ) + || f128M_isSignalingNaN( &subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f128M( &genCases_f128_a, " " ); + writeCase_z_f128M( &trueZ, trueFlags, &subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16.c new file mode 100644 index 000000000..ef9f45a5e --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_az_f16( + float16_t trueFunction( float16_t ), float16_t subjFunction( float16_t ) ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f16_isSignalingNaN( genCases_f16_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16_rx.c new file mode 100644 index 000000000..11c37e832 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f16_rx.c @@ -0,0 +1,109 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT16 + +#pragma STDC FENV_ACCESS ON + +void + test_az_f16_rx( + float16_t trueFunction( float16_t, uint_fast8_t, bool ), + float16_t subjFunction( float16_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + float16_t trueZ; + uint_fast8_t trueFlags; + float16_t subjZ; + uint_fast8_t subjFlags; + + genCases_f16_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f16_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f16_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f16_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f16_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f16_isSignalingNaN( genCases_f16_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f16_isNaN( trueZ ) + || ! f16_isNaN( subjZ ) + || f16_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f16( genCases_f16_a ); + writeCase_z_f16( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32.c new file mode 100644 index 000000000..499c07b58 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32.c @@ -0,0 +1,100 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_az_f32( + float32_t trueFunction( float32_t ), float32_t subjFunction( float32_t ) ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f32_isSignalingNaN( genCases_f32_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32_rx.c new file mode 100644 index 000000000..5aeecaaf3 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f32_rx.c @@ -0,0 +1,105 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014 The Regents of the University of California. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#pragma STDC FENV_ACCESS ON + +void + test_az_f32_rx( + float32_t trueFunction( float32_t, uint_fast8_t, bool ), + float32_t subjFunction( float32_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + float32_t trueZ; + uint_fast8_t trueFlags; + float32_t subjZ; + uint_fast8_t subjFlags; + + genCases_f32_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f32_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f32_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f32_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f32_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f32_isSignalingNaN( genCases_f32_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f32_isNaN( trueZ ) + || ! f32_isNaN( subjZ ) + || f32_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f32( genCases_f32_a, " " ); + writeCase_z_f32( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64.c new file mode 100644 index 000000000..24963142b --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64.c @@ -0,0 +1,104 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_az_f64( + float64_t trueFunction( float64_t ), float64_t subjFunction( float64_t ) ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, "\n\t" ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64_rx.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64_rx.c new file mode 100644 index 000000000..c146c7320 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/test_az_f64_rx.c @@ -0,0 +1,109 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of +California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include "platform.h" +#include "softfloat.h" +#include "genCases.h" +#include "verCases.h" +#include "writeCase.h" +#include "testLoops.h" + +#ifdef FLOAT64 + +#pragma STDC FENV_ACCESS ON + +void + test_az_f64_rx( + float64_t trueFunction( float64_t, uint_fast8_t, bool ), + float64_t subjFunction( float64_t, uint_fast8_t, bool ), + uint_fast8_t roundingMode, + bool exact + ) +{ + int count; + float64_t trueZ; + uint_fast8_t trueFlags; + float64_t subjZ; + uint_fast8_t subjFlags; + + genCases_f64_a_init(); + genCases_writeTestsTotal( testLoops_forever ); + verCases_errorCount = 0; + verCases_tenThousandsCount = 0; + count = 10000; + while ( ! genCases_done || testLoops_forever ) { + genCases_f64_a_next(); + *testLoops_trueFlagsPtr = 0; + trueZ = trueFunction( genCases_f64_a, roundingMode, exact ); + trueFlags = *testLoops_trueFlagsPtr; + testLoops_subjFlagsFunction(); + subjZ = subjFunction( genCases_f64_a, roundingMode, exact ); + subjFlags = testLoops_subjFlagsFunction(); + --count; + if ( ! count ) { + verCases_perTenThousand(); + count = 10000; + } + if ( ! f64_same( trueZ, subjZ ) || (trueFlags != subjFlags) ) { + if ( + ! verCases_checkNaNs && f64_isSignalingNaN( genCases_f64_a ) + ) { + trueFlags |= softfloat_flag_invalid; + } + if ( + verCases_checkNaNs + || ! f64_isNaN( trueZ ) + || ! f64_isNaN( subjZ ) + || f64_isSignalingNaN( subjZ ) + || (trueFlags != subjFlags) + ) { + ++verCases_errorCount; + verCases_writeErrorFound( 10000 - count ); + writeCase_a_f64( genCases_f64_a, "\n\t" ); + writeCase_z_f64( trueZ, trueFlags, subjZ, subjFlags ); + if ( verCases_errorCount == verCases_maxErrorCount ) break; + } + } + } + verCases_writeTestsPerformed( 10000 - count ); + +} + +#endif + diff --git a/wally-pipelined/testbench/fp/TestFloat-3e/source/testfloat.c b/wally-pipelined/testbench/fp/TestFloat-3e/source/testfloat.c new file mode 100644 index 000000000..f83ca6d60 --- /dev/null +++ b/wally-pipelined/testbench/fp/TestFloat-3e/source/testfloat.c @@ -0,0 +1,1715 @@ + +/*============================================================================ + +This C source file is part of TestFloat, Release 3e, a package of programs for +testing the correctness of floating-point arithmetic complying with the IEEE +Standard for Floating-Point, by John R. Hauser. + +Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the +University of California. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions, and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions, and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the University nor the names of its contributors may + be used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +=============================================================================*/ + +#include +#include +#include +#include +#include +#include +#include "platform.h" +#include "fail.h" +#include "softfloat.h" +#include "subjfloat_config.h" +#include "subjfloat.h" +#include "functions.h" +#include "genCases.h" +#include "verCases.h" +#include "testLoops.h" + +static void catchSIGINT( int signalCode ) +{ + + if ( verCases_stop ) exit( EXIT_FAILURE ); + verCases_stop = true; + +} + +static void (*subjFunctionPtr)(); + +#ifdef FLOAT16 +typedef float16_t funcType_a_ui32_z_f16( uint32_t ); +#endif +typedef float32_t funcType_a_ui32_z_f32( uint32_t ); +#ifdef FLOAT64 +typedef float64_t funcType_a_ui32_z_f64( uint32_t ); +#endif +#ifdef EXTFLOAT80 +typedef void funcType_a_ui32_z_extF80( uint32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_ui32_z_f128( uint32_t, float128_t * ); +#endif +#ifdef FLOAT16 +typedef float16_t funcType_a_ui64_z_f16( uint64_t ); +#endif +typedef float32_t funcType_a_ui64_z_f32( uint64_t ); +#ifdef FLOAT64 +typedef float64_t funcType_a_ui64_z_f64( uint64_t ); +#endif +#ifdef EXTFLOAT80 +typedef void funcType_a_ui64_z_extF80( uint64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_ui64_z_f128( uint64_t, float128_t * ); +#endif +#ifdef FLOAT16 +typedef float16_t funcType_a_i32_z_f16( int32_t ); +#endif +typedef float32_t funcType_a_i32_z_f32( int32_t ); +#ifdef FLOAT64 +typedef float64_t funcType_a_i32_z_f64( int32_t ); +#endif +#ifdef EXTFLOAT80 +typedef void funcType_a_i32_z_extF80( int32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_i32_z_f128( int32_t, float128_t * ); +#endif +#ifdef FLOAT16 +typedef float16_t funcType_a_i64_z_f16( int64_t ); +#endif +typedef float32_t funcType_a_i64_z_f32( int64_t ); +#ifdef FLOAT64 +typedef float64_t funcType_a_i64_z_f64( int64_t ); +#endif +#ifdef EXTFLOAT80 +typedef void funcType_a_i64_z_extF80( int64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_i64_z_f128( int64_t, float128_t * ); +#endif + +#ifdef FLOAT16 +typedef uint_fast32_t funcType_a_f16_z_ui32( float16_t ); +typedef uint_fast64_t funcType_a_f16_z_ui64( float16_t ); +typedef int_fast32_t funcType_a_f16_z_i32( float16_t ); +typedef int_fast64_t funcType_a_f16_z_i64( float16_t ); +typedef float32_t funcType_a_f16_z_f32( float16_t ); +#ifdef FLOAT64 +typedef float64_t funcType_a_f16_z_f64( float16_t ); +#endif +#ifdef EXTFLOAT80 +typedef void funcType_a_f16_z_extF80( float16_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_f16_z_f128( float16_t, float128_t * ); +#endif +typedef float16_t funcType_az_f16( float16_t ); +typedef float16_t funcType_abz_f16( float16_t, float16_t ); +typedef float16_t funcType_abcz_f16( float16_t, float16_t, float16_t ); +typedef bool funcType_ab_f16_z_bool( float16_t, float16_t ); +#endif + +typedef uint_fast32_t funcType_a_f32_z_ui32( float32_t ); +typedef uint_fast64_t funcType_a_f32_z_ui64( float32_t ); +typedef int_fast32_t funcType_a_f32_z_i32( float32_t ); +typedef int_fast64_t funcType_a_f32_z_i64( float32_t ); +#ifdef FLOAT16 +typedef float16_t funcType_a_f32_z_f16( float32_t ); +#endif +#ifdef FLOAT64 +typedef float64_t funcType_a_f32_z_f64( float32_t ); +#endif +#ifdef EXTFLOAT80 +typedef void funcType_a_f32_z_extF80( float32_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_f32_z_f128( float32_t, float128_t * ); +#endif +typedef float32_t funcType_az_f32( float32_t ); +typedef float32_t funcType_abz_f32( float32_t, float32_t ); +typedef float32_t funcType_abcz_f32( float32_t, float32_t, float32_t ); +typedef bool funcType_ab_f32_z_bool( float32_t, float32_t ); + +#ifdef FLOAT64 +typedef uint_fast32_t funcType_a_f64_z_ui32( float64_t ); +typedef uint_fast64_t funcType_a_f64_z_ui64( float64_t ); +typedef int_fast32_t funcType_a_f64_z_i32( float64_t ); +typedef int_fast64_t funcType_a_f64_z_i64( float64_t ); +#ifdef FLOAT16 +typedef float16_t funcType_a_f64_z_f16( float64_t ); +#endif +typedef float32_t funcType_a_f64_z_f32( float64_t ); +#ifdef EXTFLOAT80 +typedef void funcType_a_f64_z_extF80( float64_t, extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_f64_z_f128( float64_t, float128_t * ); +#endif +typedef float64_t funcType_az_f64( float64_t ); +typedef float64_t funcType_abz_f64( float64_t, float64_t ); +typedef float64_t funcType_abcz_f64( float64_t, float64_t, float64_t ); +typedef bool funcType_ab_f64_z_bool( float64_t, float64_t ); +#endif + +#ifdef EXTFLOAT80 +typedef uint_fast32_t funcType_a_extF80_z_ui32( const extFloat80_t * ); +typedef uint_fast64_t funcType_a_extF80_z_ui64( const extFloat80_t * ); +typedef int_fast32_t funcType_a_extF80_z_i32( const extFloat80_t * ); +typedef int_fast64_t funcType_a_extF80_z_i64( const extFloat80_t * ); +#ifdef FLOAT16 +typedef float16_t funcType_a_extF80_z_f16( const extFloat80_t * ); +#endif +typedef float32_t funcType_a_extF80_z_f32( const extFloat80_t * ); +#ifdef FLOAT64 +typedef float64_t funcType_a_extF80_z_f64( const extFloat80_t * ); +#endif +#ifdef FLOAT128 +typedef void funcType_a_extF80_z_f128( const extFloat80_t *, float128_t * ); +#endif +typedef void funcType_az_extF80( const extFloat80_t *, extFloat80_t * ); +typedef + void + funcType_abz_extF80( + const extFloat80_t *, const extFloat80_t *, extFloat80_t * ); +typedef + bool funcType_ab_extF80_z_bool( const extFloat80_t *, const extFloat80_t * ); +#endif + +#ifdef FLOAT128 +typedef uint_fast32_t funcType_a_f128_z_ui32( const float128_t * ); +typedef uint_fast64_t funcType_a_f128_z_ui64( const float128_t * ); +typedef int_fast32_t funcType_a_f128_z_i32( const float128_t * ); +typedef int_fast64_t funcType_a_f128_z_i64( const float128_t * ); +#ifdef FLOAT16 +typedef float16_t funcType_a_f128_z_f16( const float128_t * ); +#endif +typedef float32_t funcType_a_f128_z_f32( const float128_t * ); +#ifdef FLOAT64 +typedef float64_t funcType_a_f128_z_f64( const float128_t * ); +#endif +#ifdef EXTFLOAT80 +typedef void funcType_a_f128_z_extF80( const float128_t *, extFloat80_t * ); +#endif +typedef void funcType_az_f128( const float128_t *, float128_t * ); +typedef + void + funcType_abz_f128( const float128_t *, const float128_t *, float128_t * ); +typedef + void + funcType_abcz_f128( + const float128_t *, const float128_t *, const float128_t *, float128_t * + ); +typedef bool funcType_ab_f128_z_bool( const float128_t *, const float128_t * ); +#endif + +#ifdef FLOAT16 + +static +uint_fast32_t + subjFunction_a_f16_z_ui32_rx( + float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f16_z_ui32 *) subjFunctionPtr)( a ); + +} + +static +uint_fast64_t + subjFunction_a_f16_z_ui64_rx( + float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f16_z_ui64 *) subjFunctionPtr)( a ); + +} + +static +int_fast32_t + subjFunction_a_f16_z_i32_rx( + float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f16_z_i32 *) subjFunctionPtr)( a ); + +} + +static +int_fast64_t + subjFunction_a_f16_z_i64_rx( + float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f16_z_i64 *) subjFunctionPtr)( a ); + +} + +static +float16_t + subjFunction_az_f16_rx( float16_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_az_f16 *) subjFunctionPtr)( a ); + +} + +#endif + +static +uint_fast32_t + subjFunction_a_f32_z_ui32_rx( + float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f32_z_ui32 *) subjFunctionPtr)( a ); + +} + +static +uint_fast64_t + subjFunction_a_f32_z_ui64_rx( + float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f32_z_ui64 *) subjFunctionPtr)( a ); + +} + +static +int_fast32_t + subjFunction_a_f32_z_i32_rx( + float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f32_z_i32 *) subjFunctionPtr)( a ); + +} + +static +int_fast64_t + subjFunction_a_f32_z_i64_rx( + float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f32_z_i64 *) subjFunctionPtr)( a ); + +} + +static +float32_t + subjFunction_az_f32_rx( float32_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_az_f32 *) subjFunctionPtr)( a ); + +} + +#ifdef FLOAT64 + +static +uint_fast32_t + subjFunction_a_f64_z_ui32_rx( + float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f64_z_ui32 *) subjFunctionPtr)( a ); + +} + +static +uint_fast64_t + subjFunction_a_f64_z_ui64_rx( + float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f64_z_ui64 *) subjFunctionPtr)( a ); + +} + +static +int_fast32_t + subjFunction_a_f64_z_i32_rx( + float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f64_z_i32 *) subjFunctionPtr)( a ); + +} + +static +int_fast64_t + subjFunction_a_f64_z_i64_rx( + float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f64_z_i64 *) subjFunctionPtr)( a ); + +} + +static +float64_t + subjFunction_az_f64_rx( float64_t a, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_az_f64 *) subjFunctionPtr)( a ); + +} + +#endif + +#ifdef EXTFLOAT80 + +static +uint_fast32_t + subjFunction_a_extF80_z_ui32_rx( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_extF80_z_ui32 *) subjFunctionPtr)( aPtr ); + +} + +static +uint_fast64_t + subjFunction_a_extF80_z_ui64_rx( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_extF80_z_ui64 *) subjFunctionPtr)( aPtr ); + +} + +static +int_fast32_t + subjFunction_a_extF80_z_i32_rx( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_extF80_z_i32 *) subjFunctionPtr)( aPtr ); + +} + +static +int_fast64_t + subjFunction_a_extF80_z_i64_rx( + const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_extF80_z_i64 *) subjFunctionPtr)( aPtr ); + +} + +static +void + subjFunction_az_extF80_rx( + const extFloat80_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + extFloat80_t *zPtr + ) +{ + + return ((funcType_az_extF80 *) subjFunctionPtr)( aPtr, zPtr ); + +} + +#endif + +#ifdef FLOAT128 + +static +uint_fast32_t + subjFunction_a_f128_z_ui32_rx( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f128_z_ui32 *) subjFunctionPtr)( aPtr ); + +} + +static +uint_fast64_t + subjFunction_a_f128_z_ui64_rx( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f128_z_ui64 *) subjFunctionPtr)( aPtr ); + +} + +static +int_fast32_t + subjFunction_a_f128_z_i32_rx( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f128_z_i32 *) subjFunctionPtr)( aPtr ); + +} + +static +int_fast64_t + subjFunction_a_f128_z_i64_rx( + const float128_t *aPtr, uint_fast8_t roundingMode, bool exact ) +{ + + return ((funcType_a_f128_z_i64 *) subjFunctionPtr)( aPtr ); + +} + +static +void + subjFunction_az_f128_rx( + const float128_t *aPtr, + uint_fast8_t roundingMode, + bool exact, + float128_t *zPtr + ) +{ + + return ((funcType_az_f128 *) subjFunctionPtr)( aPtr, zPtr ); + +} + +#endif + +static +void + testFunctionInstance( + int functionCode, uint_fast8_t roundingMode, bool exact ) +{ +#ifdef FLOAT16 + funcType_abz_f16 *trueFunction_abz_f16; + funcType_ab_f16_z_bool *trueFunction_ab_f16_z_bool; +#endif + funcType_abz_f32 *trueFunction_abz_f32; + funcType_ab_f32_z_bool *trueFunction_ab_f32_z_bool; +#ifdef FLOAT64 + funcType_abz_f64 *trueFunction_abz_f64; + funcType_ab_f64_z_bool *trueFunction_ab_f64_z_bool; +#endif +#ifdef EXTFLOAT80 + funcType_abz_extF80 *trueFunction_abz_extF80; + funcType_ab_extF80_z_bool *trueFunction_ab_extF80_z_bool; +#endif +#ifdef FLOAT128 + funcType_abz_f128 *trueFunction_abz_f128; + funcType_ab_f128_z_bool *trueFunction_ab_f128_z_bool; +#endif + + fputs( "Testing ", stderr ); + verCases_writeFunctionName( stderr ); + fputs( ".\n", stderr ); + switch ( functionCode ) { + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ +#ifdef FLOAT16 +#ifdef SUBJ_UI32_TO_F16 + case UI32_TO_F16: + test_a_ui32_z_f16( + ui32_to_f16, (funcType_a_ui32_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef SUBJ_UI32_TO_F32 + case UI32_TO_F32: + test_a_ui32_z_f32( + ui32_to_f32, (funcType_a_ui32_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef FLOAT64 +#ifdef SUBJ_UI32_TO_F64 + case UI32_TO_F64: + test_a_ui32_z_f64( + ui32_to_f64, (funcType_a_ui32_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_UI32_TO_EXTF80 + case UI32_TO_EXTF80: + test_a_ui32_z_extF80( + ui32_to_extF80M, (funcType_a_ui32_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_UI32_TO_F128 + case UI32_TO_F128: + test_a_ui32_z_f128( + ui32_to_f128M, (funcType_a_ui32_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT16 +#ifdef SUBJ_UI64_TO_F16 + case UI64_TO_F16: + test_a_ui64_z_f16( + ui64_to_f16, (funcType_a_ui64_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef SUBJ_UI64_TO_F32 + case UI64_TO_F32: + test_a_ui64_z_f32( + ui64_to_f32, (funcType_a_ui64_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef FLOAT64 +#ifdef SUBJ_UI64_TO_F64 + case UI64_TO_F64: + test_a_ui64_z_f64( + ui64_to_f64, (funcType_a_ui64_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_UI64_TO_EXTF80 + case UI64_TO_EXTF80: + test_a_ui64_z_extF80( + ui64_to_extF80M, (funcType_a_ui64_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_UI64_TO_F128 + case UI64_TO_F128: + test_a_ui64_z_f128( + ui64_to_f128M, (funcType_a_ui64_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT16 +#ifdef SUBJ_I32_TO_F16 + case I32_TO_F16: + test_a_i32_z_f16( + i32_to_f16, (funcType_a_i32_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef SUBJ_I32_TO_F32 + case I32_TO_F32: + test_a_i32_z_f32( + i32_to_f32, (funcType_a_i32_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef FLOAT64 +#ifdef SUBJ_I32_TO_F64 + case I32_TO_F64: + test_a_i32_z_f64( + i32_to_f64, (funcType_a_i32_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_I32_TO_EXTF80 + case I32_TO_EXTF80: + test_a_i32_z_extF80( + i32_to_extF80M, (funcType_a_i32_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_I32_TO_F128 + case I32_TO_F128: + test_a_i32_z_f128( + i32_to_f128M, (funcType_a_i32_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT16 +#ifdef SUBJ_I64_TO_F16 + case I64_TO_F16: + test_a_i64_z_f16( + i64_to_f16, (funcType_a_i64_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef SUBJ_I64_TO_F32 + case I64_TO_F32: + test_a_i64_z_f32( + i64_to_f32, (funcType_a_i64_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef FLOAT64 +#ifdef SUBJ_I64_TO_F64 + case I64_TO_F64: + test_a_i64_z_f64( + i64_to_f64, (funcType_a_i64_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_I64_TO_EXTF80 + case I64_TO_EXTF80: + test_a_i64_z_extF80( + i64_to_extF80M, (funcType_a_i64_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_I64_TO_F128 + case I64_TO_F128: + test_a_i64_z_f128( + i64_to_f128M, (funcType_a_i64_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ +#ifdef FLOAT16 + case F16_TO_UI32: + test_a_f16_z_ui32_rx( + f16_to_ui32, subjFunction_a_f16_z_ui32_rx, roundingMode, exact ); + break; + case F16_TO_UI64: + test_a_f16_z_ui64_rx( + f16_to_ui64, subjFunction_a_f16_z_ui64_rx, roundingMode, exact ); + break; + case F16_TO_I32: + test_a_f16_z_i32_rx( + f16_to_i32, subjFunction_a_f16_z_i32_rx, roundingMode, exact ); + break; + case F16_TO_I64: + test_a_f16_z_i64_rx( + f16_to_i64, subjFunction_a_f16_z_i64_rx, roundingMode, exact ); + break; +#ifdef SUBJ_F16_TO_F32 + case F16_TO_F32: + test_a_f16_z_f32( + f16_to_f32, (funcType_a_f16_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef FLOAT64 +#ifdef SUBJ_F16_TO_F64 + case F16_TO_F64: + test_a_f16_z_f64( + f16_to_f64, (funcType_a_f16_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F16_TO_EXTF80 + case F16_TO_EXTF80: + test_a_f16_z_extF80( + f16_to_extF80M, (funcType_a_f16_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_F16_TO_F128 + case F16_TO_F128: + test_a_f16_z_f128( + f16_to_f128M, (funcType_a_f16_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif + case F16_ROUNDTOINT: + test_az_f16_rx( + f16_roundToInt, subjFunction_az_f16_rx, roundingMode, exact ); + break; +#ifdef SUBJ_F16_ADD + case F16_ADD: + trueFunction_abz_f16 = f16_add; + goto test_abz_f16; +#endif +#ifdef SUBJ_F16_SUB + case F16_SUB: + trueFunction_abz_f16 = f16_sub; + goto test_abz_f16; +#endif +#ifdef SUBJ_F16_MUL + case F16_MUL: + trueFunction_abz_f16 = f16_mul; + goto test_abz_f16; +#endif +#ifdef SUBJ_F16_MULADD + case F16_MULADD: + test_abcz_f16( f16_mulAdd, (funcType_abcz_f16 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F16_DIV + case F16_DIV: + trueFunction_abz_f16 = f16_div; + goto test_abz_f16; +#endif +#ifdef SUBJ_F16_REM + case F16_REM: + trueFunction_abz_f16 = f16_rem; + goto test_abz_f16; +#endif + test_abz_f16: + test_abz_f16( + trueFunction_abz_f16, (funcType_abz_f16 *) subjFunctionPtr ); + break; +#ifdef SUBJ_F16_SQRT + case F16_SQRT: + test_az_f16( f16_sqrt, (funcType_az_f16 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F16_EQ + case F16_EQ: + trueFunction_ab_f16_z_bool = f16_eq; + goto test_ab_f16_z_bool; +#endif +#ifdef SUBJ_F16_LE + case F16_LE: + trueFunction_ab_f16_z_bool = f16_le; + goto test_ab_f16_z_bool; +#endif +#ifdef SUBJ_F16_LT + case F16_LT: + trueFunction_ab_f16_z_bool = f16_lt; + goto test_ab_f16_z_bool; +#endif +#ifdef SUBJ_F16_EQ_SIGNALING + case F16_EQ_SIGNALING: + trueFunction_ab_f16_z_bool = f16_eq_signaling; + goto test_ab_f16_z_bool; +#endif +#ifdef SUBJ_F16_LE_QUIET + case F16_LE_QUIET: + trueFunction_ab_f16_z_bool = f16_le_quiet; + goto test_ab_f16_z_bool; +#endif +#ifdef SUBJ_F16_LT_QUIET + case F16_LT_QUIET: + trueFunction_ab_f16_z_bool = f16_lt_quiet; + goto test_ab_f16_z_bool; +#endif + test_ab_f16_z_bool: + test_ab_f16_z_bool( + trueFunction_ab_f16_z_bool, + (funcType_ab_f16_z_bool *) subjFunctionPtr + ); + break; +#endif + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ + case F32_TO_UI32: + test_a_f32_z_ui32_rx( + f32_to_ui32, subjFunction_a_f32_z_ui32_rx, roundingMode, exact ); + break; + case F32_TO_UI64: + test_a_f32_z_ui64_rx( + f32_to_ui64, subjFunction_a_f32_z_ui64_rx, roundingMode, exact ); + break; + case F32_TO_I32: + test_a_f32_z_i32_rx( + f32_to_i32, subjFunction_a_f32_z_i32_rx, roundingMode, exact ); + break; + case F32_TO_I64: + test_a_f32_z_i64_rx( + f32_to_i64, subjFunction_a_f32_z_i64_rx, roundingMode, exact ); + break; +#ifdef FLOAT16 +#ifdef SUBJ_F32_TO_F16 + case F32_TO_F16: + test_a_f32_z_f16( + f32_to_f16, (funcType_a_f32_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT64 +#ifdef SUBJ_F32_TO_F64 + case F32_TO_F64: + test_a_f32_z_f64( + f32_to_f64, (funcType_a_f32_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F32_TO_EXTF80 + case F32_TO_EXTF80: + test_a_f32_z_extF80( + f32_to_extF80M, (funcType_a_f32_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_F32_TO_F128 + case F32_TO_F128: + test_a_f32_z_f128( + f32_to_f128M, (funcType_a_f32_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif + case F32_ROUNDTOINT: + test_az_f32_rx( + f32_roundToInt, subjFunction_az_f32_rx, roundingMode, exact ); + break; +#ifdef SUBJ_F32_ADD + case F32_ADD: + trueFunction_abz_f32 = f32_add; + goto test_abz_f32; +#endif +#ifdef SUBJ_F32_SUB + case F32_SUB: + trueFunction_abz_f32 = f32_sub; + goto test_abz_f32; +#endif +#ifdef SUBJ_F32_MUL + case F32_MUL: + trueFunction_abz_f32 = f32_mul; + goto test_abz_f32; +#endif +#ifdef SUBJ_F32_MULADD + case F32_MULADD: + test_abcz_f32( f32_mulAdd, (funcType_abcz_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F32_DIV + case F32_DIV: + trueFunction_abz_f32 = f32_div; + goto test_abz_f32; +#endif +#ifdef SUBJ_F32_REM + case F32_REM: + trueFunction_abz_f32 = f32_rem; + goto test_abz_f32; +#endif + test_abz_f32: + test_abz_f32( + trueFunction_abz_f32, (funcType_abz_f32 *) subjFunctionPtr ); + break; +#ifdef SUBJ_F32_SQRT + case F32_SQRT: + test_az_f32( f32_sqrt, (funcType_az_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F32_EQ + case F32_EQ: + trueFunction_ab_f32_z_bool = f32_eq; + goto test_ab_f32_z_bool; +#endif +#ifdef SUBJ_F32_LE + case F32_LE: + trueFunction_ab_f32_z_bool = f32_le; + goto test_ab_f32_z_bool; +#endif +#ifdef SUBJ_F32_LT + case F32_LT: + trueFunction_ab_f32_z_bool = f32_lt; + goto test_ab_f32_z_bool; +#endif +#ifdef SUBJ_F32_EQ_SIGNALING + case F32_EQ_SIGNALING: + trueFunction_ab_f32_z_bool = f32_eq_signaling; + goto test_ab_f32_z_bool; +#endif +#ifdef SUBJ_F32_LE_QUIET + case F32_LE_QUIET: + trueFunction_ab_f32_z_bool = f32_le_quiet; + goto test_ab_f32_z_bool; +#endif +#ifdef SUBJ_F32_LT_QUIET + case F32_LT_QUIET: + trueFunction_ab_f32_z_bool = f32_lt_quiet; + goto test_ab_f32_z_bool; +#endif + test_ab_f32_z_bool: + test_ab_f32_z_bool( + trueFunction_ab_f32_z_bool, + (funcType_ab_f32_z_bool *) subjFunctionPtr + ); + break; + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ +#ifdef FLOAT64 + case F64_TO_UI32: + test_a_f64_z_ui32_rx( + f64_to_ui32, subjFunction_a_f64_z_ui32_rx, roundingMode, exact ); + break; + case F64_TO_UI64: + test_a_f64_z_ui64_rx( + f64_to_ui64, subjFunction_a_f64_z_ui64_rx, roundingMode, exact ); + break; + case F64_TO_I32: + test_a_f64_z_i32_rx( + f64_to_i32, subjFunction_a_f64_z_i32_rx, roundingMode, exact ); + break; + case F64_TO_I64: + test_a_f64_z_i64_rx( + f64_to_i64, subjFunction_a_f64_z_i64_rx, roundingMode, exact ); + break; +#ifdef FLOAT16 +#ifdef SUBJ_F64_TO_F16 + case F64_TO_F16: + test_a_f64_z_f16( + f64_to_f16, (funcType_a_f64_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef SUBJ_F64_TO_F32 + case F64_TO_F32: + test_a_f64_z_f32( + f64_to_f32, (funcType_a_f64_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F64_TO_EXTF80 + case F64_TO_EXTF80: + test_a_f64_z_extF80( + f64_to_extF80M, (funcType_a_f64_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_F64_TO_F128 + case F64_TO_F128: + test_a_f64_z_f128( + f64_to_f128M, (funcType_a_f64_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif + case F64_ROUNDTOINT: + test_az_f64_rx( + f64_roundToInt, subjFunction_az_f64_rx, roundingMode, exact ); + break; +#ifdef SUBJ_F64_ADD + case F64_ADD: + trueFunction_abz_f64 = f64_add; + goto test_abz_f64; +#endif +#ifdef SUBJ_F64_SUB + case F64_SUB: + trueFunction_abz_f64 = f64_sub; + goto test_abz_f64; +#endif +#ifdef SUBJ_F64_MUL + case F64_MUL: + trueFunction_abz_f64 = f64_mul; + goto test_abz_f64; +#endif +#ifdef SUBJ_F64_MULADD + case F64_MULADD: + test_abcz_f64( f64_mulAdd, (funcType_abcz_f64 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F64_DIV + case F64_DIV: + trueFunction_abz_f64 = f64_div; + goto test_abz_f64; +#endif +#ifdef SUBJ_F64_REM + case F64_REM: + trueFunction_abz_f64 = f64_rem; + goto test_abz_f64; +#endif + test_abz_f64: + test_abz_f64( + trueFunction_abz_f64, (funcType_abz_f64 *) subjFunctionPtr ); + break; +#ifdef SUBJ_F64_SQRT + case F64_SQRT: + test_az_f64( f64_sqrt, (funcType_az_f64 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F64_EQ + case F64_EQ: + trueFunction_ab_f64_z_bool = f64_eq; + goto test_ab_f64_z_bool; +#endif +#ifdef SUBJ_F64_LE + case F64_LE: + trueFunction_ab_f64_z_bool = f64_le; + goto test_ab_f64_z_bool; +#endif +#ifdef SUBJ_F64_LT + case F64_LT: + trueFunction_ab_f64_z_bool = f64_lt; + goto test_ab_f64_z_bool; +#endif +#ifdef SUBJ_F64_EQ_SIGNALING + case F64_EQ_SIGNALING: + trueFunction_ab_f64_z_bool = f64_eq_signaling; + goto test_ab_f64_z_bool; +#endif +#ifdef SUBJ_F64_LE_QUIET + case F64_LE_QUIET: + trueFunction_ab_f64_z_bool = f64_le_quiet; + goto test_ab_f64_z_bool; +#endif +#ifdef SUBJ_F64_LT_QUIET + case F64_LT_QUIET: + trueFunction_ab_f64_z_bool = f64_lt_quiet; + goto test_ab_f64_z_bool; +#endif + test_ab_f64_z_bool: + test_ab_f64_z_bool( + trueFunction_ab_f64_z_bool, + (funcType_ab_f64_z_bool *) subjFunctionPtr + ); + break; +#endif + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ +#ifdef EXTFLOAT80 + case EXTF80_TO_UI32: + test_a_extF80_z_ui32_rx( + extF80M_to_ui32, + subjFunction_a_extF80_z_ui32_rx, + roundingMode, + exact + ); + break; + case EXTF80_TO_UI64: + test_a_extF80_z_ui64_rx( + extF80M_to_ui64, + subjFunction_a_extF80_z_ui64_rx, + roundingMode, + exact + ); + break; + case EXTF80_TO_I32: + test_a_extF80_z_i32_rx( + extF80M_to_i32, subjFunction_a_extF80_z_i32_rx, roundingMode, exact + ); + break; + case EXTF80_TO_I64: + test_a_extF80_z_i64_rx( + extF80M_to_i64, subjFunction_a_extF80_z_i64_rx, roundingMode, exact + ); + break; +#ifdef FLOAT16 +#ifdef SUBJ_EXTF80_TO_F16 + case EXTF80_TO_F16: + test_a_extF80_z_f16( + extF80M_to_f16, (funcType_a_extF80_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef SUBJ_EXTF80_TO_F32 + case EXTF80_TO_F32: + test_a_extF80_z_f32( + extF80M_to_f32, (funcType_a_extF80_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef FLOAT64 +#ifdef SUBJ_EXTF80_TO_F64 + case EXTF80_TO_F64: + test_a_extF80_z_f64( + extF80M_to_f64, (funcType_a_extF80_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef FLOAT128 +#ifdef SUBJ_EXTF80_TO_F128 + case EXTF80_TO_F128: + test_a_extF80_z_f128( + extF80M_to_f128M, (funcType_a_extF80_z_f128 *) subjFunctionPtr ); + break; +#endif +#endif + case EXTF80_ROUNDTOINT: + test_az_extF80_rx( + extF80M_roundToInt, subjFunction_az_extF80_rx, roundingMode, exact + ); + break; +#ifdef SUBJ_EXTF80_ADD + case EXTF80_ADD: + trueFunction_abz_extF80 = extF80M_add; + goto test_abz_extF80; +#endif +#ifdef SUBJ_EXTF80_SUB + case EXTF80_SUB: + trueFunction_abz_extF80 = extF80M_sub; + goto test_abz_extF80; +#endif +#ifdef SUBJ_EXTF80_MUL + case EXTF80_MUL: + trueFunction_abz_extF80 = extF80M_mul; + goto test_abz_extF80; +#endif +#ifdef SUBJ_EXTF80_DIV + case EXTF80_DIV: + trueFunction_abz_extF80 = extF80M_div; + goto test_abz_extF80; +#endif +#ifdef SUBJ_EXTF80_REM + case EXTF80_REM: + trueFunction_abz_extF80 = extF80M_rem; + goto test_abz_extF80; +#endif + test_abz_extF80: + test_abz_extF80( + trueFunction_abz_extF80, (funcType_abz_extF80 *) subjFunctionPtr ); + break; +#ifdef SUBJ_EXTF80_SQRT + case EXTF80_SQRT: + test_az_extF80( extF80M_sqrt, (funcType_az_extF80 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_EXTF80_EQ + case EXTF80_EQ: + trueFunction_ab_extF80_z_bool = extF80M_eq; + goto test_ab_extF80_z_bool; +#endif +#ifdef SUBJ_EXTF80_LE + case EXTF80_LE: + trueFunction_ab_extF80_z_bool = extF80M_le; + goto test_ab_extF80_z_bool; +#endif +#ifdef SUBJ_EXTF80_LT + case EXTF80_LT: + trueFunction_ab_extF80_z_bool = extF80M_lt; + goto test_ab_extF80_z_bool; +#endif +#ifdef SUBJ_EXTF80_EQ_SIGNALING + case EXTF80_EQ_SIGNALING: + trueFunction_ab_extF80_z_bool = extF80M_eq_signaling; + goto test_ab_extF80_z_bool; +#endif +#ifdef SUBJ_EXTF80_LE_QUIET + case EXTF80_LE_QUIET: + trueFunction_ab_extF80_z_bool = extF80M_le_quiet; + goto test_ab_extF80_z_bool; +#endif +#ifdef SUBJ_EXTF80_LT_QUIET + case EXTF80_LT_QUIET: + trueFunction_ab_extF80_z_bool = extF80M_lt_quiet; + goto test_ab_extF80_z_bool; +#endif + test_ab_extF80_z_bool: + test_ab_extF80_z_bool( + trueFunction_ab_extF80_z_bool, + (funcType_ab_extF80_z_bool *) subjFunctionPtr + ); + break; +#endif + /*-------------------------------------------------------------------- + *--------------------------------------------------------------------*/ +#ifdef FLOAT128 + case F128_TO_UI32: + test_a_f128_z_ui32_rx( + f128M_to_ui32, subjFunction_a_f128_z_ui32_rx, roundingMode, exact + ); + break; + case F128_TO_UI64: + test_a_f128_z_ui64_rx( + f128M_to_ui64, subjFunction_a_f128_z_ui64_rx, roundingMode, exact + ); + break; + case F128_TO_I32: + test_a_f128_z_i32_rx( + f128M_to_i32, subjFunction_a_f128_z_i32_rx, roundingMode, exact ); + break; + case F128_TO_I64: + test_a_f128_z_i64_rx( + f128M_to_i64, subjFunction_a_f128_z_i64_rx, roundingMode, exact ); + break; +#ifdef FLOAT16 +#ifdef SUBJ_F128_TO_F16 + case F128_TO_F16: + test_a_f128_z_f16( + f128M_to_f16, (funcType_a_f128_z_f16 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef SUBJ_F128_TO_F32 + case F128_TO_F32: + test_a_f128_z_f32( + f128M_to_f32, (funcType_a_f128_z_f32 *) subjFunctionPtr ); + break; +#endif +#ifdef FLOAT64 +#ifdef SUBJ_F128_TO_F64 + case F128_TO_F64: + test_a_f128_z_f64( + f128M_to_f64, (funcType_a_f128_z_f64 *) subjFunctionPtr ); + break; +#endif +#endif +#ifdef EXTFLOAT80 +#ifdef SUBJ_F128_TO_EXTF80 + case F128_TO_EXTF80: + test_a_f128_z_extF80( + f128M_to_extF80M, (funcType_a_f128_z_extF80 *) subjFunctionPtr ); + break; +#endif +#endif + case F128_ROUNDTOINT: + test_az_f128_rx( + f128M_roundToInt, subjFunction_az_f128_rx, roundingMode, exact ); + break; +#ifdef SUBJ_F128_ADD + case F128_ADD: + trueFunction_abz_f128 = f128M_add; + goto test_abz_f128; +#endif +#ifdef SUBJ_F128_SUB + case F128_SUB: + trueFunction_abz_f128 = f128M_sub; + goto test_abz_f128; +#endif +#ifdef SUBJ_F128_MUL + case F128_MUL: + trueFunction_abz_f128 = f128M_mul; + goto test_abz_f128; +#endif +#ifdef SUBJ_F128_MULADD + case F128_MULADD: + test_abcz_f128( f128M_mulAdd, (funcType_abcz_f128 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F128_DIV + case F128_DIV: + trueFunction_abz_f128 = f128M_div; + goto test_abz_f128; +#endif +#ifdef SUBJ_F128_REM + case F128_REM: + trueFunction_abz_f128 = f128M_rem; + goto test_abz_f128; +#endif + test_abz_f128: + test_abz_f128( + trueFunction_abz_f128, (funcType_abz_f128 *) subjFunctionPtr ); + break; +#ifdef SUBJ_F128_SQRT + case F128_SQRT: + test_az_f128( f128M_sqrt, (funcType_az_f128 *) subjFunctionPtr ); + break; +#endif +#ifdef SUBJ_F128_EQ + case F128_EQ: + trueFunction_ab_f128_z_bool = f128M_eq; + goto test_ab_f128_z_bool; +#endif +#ifdef SUBJ_F128_LE + case F128_LE: + trueFunction_ab_f128_z_bool = f128M_le; + goto test_ab_f128_z_bool; +#endif +#ifdef SUBJ_F128_LT + case F128_LT: + trueFunction_ab_f128_z_bool = f128M_lt; + goto test_ab_f128_z_bool; +#endif +#ifdef SUBJ_F128_EQ_SIGNALING + case F128_EQ_SIGNALING: + trueFunction_ab_f128_z_bool = f128M_eq_signaling; + goto test_ab_f128_z_bool; +#endif +#ifdef SUBJ_F128_LE_QUIET + case F128_LE_QUIET: + trueFunction_ab_f128_z_bool = f128M_le_quiet; + goto test_ab_f128_z_bool; +#endif +#ifdef SUBJ_F128_LT_QUIET + case F128_LT_QUIET: + trueFunction_ab_f128_z_bool = f128M_lt_quiet; + goto test_ab_f128_z_bool; +#endif + test_ab_f128_z_bool: + test_ab_f128_z_bool( + trueFunction_ab_f128_z_bool, + (funcType_ab_f128_z_bool *) subjFunctionPtr + ); + break; +#endif + } + if ( (verCases_errorStop && verCases_anyErrors) || verCases_stop ) { + verCases_exitWithStatus(); + } + +} + +static +void + testFunction( + const struct standardFunctionInfo *standardFunctionInfoPtr, + uint_fast8_t roundingPrecisionIn, + int roundingCodeIn + ) +{ + int functionCode, functionAttribs; + bool standardFunctionHasFixedRounding; + int roundingCode; + bool exact; + uint_fast8_t roundingPrecision, roundingMode; + + functionCode = standardFunctionInfoPtr->functionCode; + functionAttribs = functionInfos[functionCode].attribs; + standardFunctionHasFixedRounding = false; + if ( functionAttribs & FUNC_ARG_ROUNDINGMODE ) { + roundingCode = standardFunctionInfoPtr->roundingCode; + if ( roundingCode ) { + standardFunctionHasFixedRounding = true; + roundingCodeIn = roundingCode; + } + } + exact = standardFunctionInfoPtr->exact; + verCases_functionNamePtr = standardFunctionInfoPtr->namePtr; + roundingPrecision = 32; + for (;;) { + if ( functionAttribs & FUNC_EFF_ROUNDINGPRECISION ) { + if ( roundingPrecisionIn ) roundingPrecision = roundingPrecisionIn; + } else { + roundingPrecision = 0; + } +#ifdef EXTFLOAT80 + verCases_roundingPrecision = roundingPrecision; + if ( roundingPrecision ) { + extF80_roundingPrecision = roundingPrecision; + subjfloat_setExtF80RoundingPrecision( roundingPrecision ); + } +#endif + for ( + roundingCode = 1; roundingCode < NUM_ROUNDINGMODES; ++roundingCode + ) { +#ifndef SUBJFLOAT_ROUND_NEAR_MAXMAG + if ( roundingCode != ROUND_NEAR_MAXMAG ) { +#endif +#if defined FLOAT_ROUND_ODD && ! defined SUBJFLOAT_ROUND_NEAR_MAXMAG + if ( roundingCode != ROUND_ODD ) { +#endif + if ( + functionAttribs + & (FUNC_ARG_ROUNDINGMODE | FUNC_EFF_ROUNDINGMODE) + ) { + if ( roundingCodeIn ) roundingCode = roundingCodeIn; + } else { + roundingCode = 0; + } + verCases_roundingCode = + standardFunctionHasFixedRounding ? 0 : roundingCode; + if ( roundingCode ) { + roundingMode = roundingModes[roundingCode]; + softfloat_roundingMode = roundingMode; + if ( ! standardFunctionHasFixedRounding ) { + subjfloat_setRoundingMode( roundingMode ); + } + } + testFunctionInstance( functionCode, roundingMode, exact ); + if ( roundingCodeIn || ! roundingCode ) break; +#if defined FLOAT_ROUND_ODD && ! defined SUBJFLOAT_ROUND_NEAR_MAXMAG + } +#endif +#ifndef SUBJFLOAT_ROUND_NEAR_MAXMAG + } +#endif + } + if ( roundingPrecisionIn || ! roundingPrecision ) break; + if ( roundingPrecision == 80 ) { + break; + } else if ( roundingPrecision == 64 ) { + roundingPrecision = 80; + } else if ( roundingPrecision == 32 ) { + roundingPrecision = 64; + } + } + +} + +int main( int argc, char *argv[] ) +{ + bool haveFunctionArg; + const struct standardFunctionInfo *standardFunctionInfoPtr; + int numOperands; + uint_fast8_t roundingPrecision; + int roundingCode; + const char *argPtr; + void (*const *subjFunctionPtrPtr)(); + const char *functionNamePtr; + unsigned long ui; + long i; + int functionMatchAttrib; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + fail_programName = "testfloat"; + if ( argc <= 1 ) goto writeHelpMessage; + genCases_setLevel( 1 ); + verCases_maxErrorCount = 20; + testLoops_trueFlagsPtr = &softfloat_exceptionFlags; + testLoops_subjFlagsFunction = subjfloat_clearExceptionFlags; + haveFunctionArg = false; + standardFunctionInfoPtr = 0; + numOperands = 0; + roundingPrecision = 0; + roundingCode = 0; + for (;;) { + --argc; + if ( ! argc ) break; + argPtr = *++argv; + if ( ! argPtr ) break; + if ( argPtr[0] == '-' ) ++argPtr; + if ( + ! strcmp( argPtr, "help" ) || ! strcmp( argPtr, "-help" ) + || ! strcmp( argPtr, "h" ) + ) { + writeHelpMessage: + fputs( +"testfloat [