diff options
Diffstat (limited to 'tests/test-progs/insttest/src/riscv/rv64f.cpp')
| -rw-r--r-- | tests/test-progs/insttest/src/riscv/rv64f.cpp | 694 |
1 files changed, 694 insertions, 0 deletions
diff --git a/tests/test-progs/insttest/src/riscv/rv64f.cpp b/tests/test-progs/insttest/src/riscv/rv64f.cpp new file mode 100644 index 000000000..f8b79f42a --- /dev/null +++ b/tests/test-progs/insttest/src/riscv/rv64f.cpp @@ -0,0 +1,694 @@ +/* + * Copyright (c) 2016 The University of Virginia + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Authors: Alec Roelke + */ + +#include <cstdint> +#include <limits> + +#include "insttest.h" +#include "rv64f.h" + +int main() +{ + using namespace std; + using namespace insttest; + + // FLAGS + expect<uint64_t>(0, []{ + F::fsflags(0); + return F::frflags(); + }, "clear fsflags"); + + // Memory + expect<float>(3.14, []{return F::load(3.14);}, "flw"); + expect<float>(1.816, []{return F::store(1.816);}, "fsw"); + + // FMADD.S + expect<float>(7.11624, []{return F::fmadd_s(3.14, 1.816, 1.414);}, + "fmadd.s"); + expect<bool>(true, []{ + float fd = F::fmadd_s(numeric_limits<float>::quiet_NaN(), 3.14, + 1.816); + return F::isquietnan(fd); + }, "fmadd.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fmadd_s(3.14, numeric_limits<float>::signaling_NaN(), + 1.816); + return F::isquietnan(fd); + }, "fmadd.s, signaling NaN"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fmadd_s(3.14, numeric_limits<float>::infinity(), + 1.414);}, + "fmadd.s, infinity"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fmadd_s(3.14, -numeric_limits<float>::infinity(), + 1.414);}, + "fmadd.s, -infinity"); + + // FMSUB.S + expect<float>(4.28824, []{return F::fmsub_s(3.14, 1.816, 1.414);}, + "fmsub.s"); + expect<bool>(true, []{ + float fd = F::fmsub_s(3.14, numeric_limits<float>::quiet_NaN(), + 1.816); + return F::isquietnan(fd); + }, "fmsub.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fmsub_s(3.14, 1.816, + numeric_limits<float>::signaling_NaN()); + return F::isquietnan(fd); + }, "fmsub.s, signaling NaN"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fmsub_s(numeric_limits<float>::infinity(), 1.816, + 1.414);}, + "fmsub.s, infinity"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fmsub_s(3.14, -numeric_limits<float>::infinity(), + 1.414);}, + "fmsub.s, -infinity"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fmsub_s(3.14, 1.816, + numeric_limits<float>::infinity());}, + "fmsub.s, subtract infinity"); + + // FNMSUB.S + expect<float>(-4.28824, []{return F::fnmsub_s(3.14, 1.816, 1.414);}, + "fnmsub.s"); + expect<bool>(true, []{ + float fd = F::fnmsub_s(3.14, 1.816, + numeric_limits<float>::quiet_NaN()); + return F::isquietnan(fd); + }, "fnmsub.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fnmsub_s(numeric_limits<float>::signaling_NaN(), + 1.816, 1.414); + return F::isquietnan(fd); + }, "fnmsub.s, signaling NaN"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fnmsub_s(numeric_limits<float>::infinity(), + 1.816, 1.414);}, + "fnmsub.s, infinity"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fnmsub_s(3.14, -numeric_limits<float>::infinity(), + 1.414);}, + "fnmsub.s, -infinity"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fnmsub_s(3.14, 1.816, + numeric_limits<float>::infinity());}, + "fnmsub.s, subtract infinity"); + + // FNMADD.S + expect<float>(-7.11624, []{return F::fnmadd_s(3.14, 1.816, 1.414);}, + "fnmadd.s"); + expect<bool>(true, []{ + float fd = F::fnmadd_s(numeric_limits<float>::quiet_NaN(), 3.14, + 1.816); + return F::isquietnan(fd); + }, "fnmadd.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fnmadd_s(3.14,numeric_limits<float>::signaling_NaN(), + 1.816); + return F::isquietnan(fd); + }, "fnmadd.s, signaling NaN"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fnmadd_s(3.14, numeric_limits<float>::infinity(), + 1.414);}, + "fnmadd.s, infinity"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fnmadd_s(3.14, -numeric_limits<float>::infinity(), + 1.414);}, + "fnmadd.s, -infinity"); + + // FADD.S + expect<float>(4.554, []{return F::fadd_s(3.14, 1.414);}, "fadd.s"); + expect<bool>(true, []{ + float fd = F::fadd_s(numeric_limits<float>::quiet_NaN(), 1.414); + return F::isquietnan(fd); + }, "fadd.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fadd_s(3.14, numeric_limits<float>::signaling_NaN()); + return F::isquietnan(fd); + }, "fadd.s, signaling NaN"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fadd_s(3.14, numeric_limits<float>::infinity());}, + "fadd.s, infinity"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fadd_s(-numeric_limits<float>::infinity(), 1.816);}, + "fadd.s, -infinity"); + + // FSUB.S + expect<float>(F::number(0xbfdced92), []{return F::fsub_s(1.414, 3.14);}, + "fsub.s"); + expect<bool>(true, []{ + float fd = F::fsub_s(numeric_limits<float>::quiet_NaN(), 1.414); + return F::isquietnan(fd); + }, "fsub.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fsub_s(3.14, numeric_limits<float>::signaling_NaN()); + return F::isquietnan(fd); + }, "fsub.s, signaling NaN"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fsub_s(numeric_limits<float>::infinity(), 3.14);}, + "fsub.s, infinity"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fsub_s(-numeric_limits<float>::infinity(), 3.14);}, + "fsub.s, -infinity"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fsub_s(1.414, numeric_limits<float>::infinity());}, + "fsub.s, subtract infinity"); + + // FMUL.S + expect<float>(F::number(0x4024573b), []{return F::fmul_s(1.816, 1.414);}, + "fmul.s"); + expect<bool>(true, []{ + float fd = F::fmul_s(numeric_limits<float>::quiet_NaN(), 1.414); + return F::isquietnan(fd); + }, "fmul.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fmul_s(1.816, + numeric_limits<float>::signaling_NaN()); + return F::isquietnan(fd); + }, "fmul.s, signaling NaN"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fmul_s(numeric_limits<float>::infinity(), 2.718);}, + "fmul.s, infinity"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fmul_s(2.5966, -numeric_limits<float>::infinity());}, + "fmul.s, -infinity"); + expect<bool>(true, []{ + float fd = F::fmul_s(0.0, numeric_limits<float>::infinity()); + return F::isquietnan(fd); + }, "fmul.s, 0*infinity"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fmul_s(numeric_limits<float>::max(), 2.0);}, + "fmul.s, overflow"); + expect<float>(0.0, + []{return F::fmul_s(numeric_limits<float>::min(), + numeric_limits<float>::min());}, + "fmul.s, underflow"); + + // FDIV.S + expect<float>(2.5, []{return F::fdiv_s(10.0, 4.0);}, "fdiv.s"); + expect<bool>(true, []{ + float fd = F::fdiv_s(numeric_limits<float>::quiet_NaN(), 4.0); + return F::isquietnan(fd); + }, "fdiv.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fdiv_s(10.0, numeric_limits<float>::signaling_NaN()); + return F::isquietnan(fd); + }, "fdiv.s, signaling NaN"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fdiv_s(10.0, 0.0);}, "fdiv.s/0"); + expect<float>(0.0, + []{return F::fdiv_s(10.0, numeric_limits<float>::infinity());}, + "fdiv.s/infinity"); + expect<bool>(true, []{ + float fd = F::fdiv_s(numeric_limits<float>::infinity(), + numeric_limits<float>::infinity()); + return F::isquietnan(fd); + }, "fdiv.s, infinity/infinity"); + expect<bool>(true, []{ + float fd = F::fdiv_s(0.0, 0.0); + return F::isquietnan(fd); + }, "fdiv.s, 0/0"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fdiv_s(numeric_limits<float>::infinity(), 0.0);}, + "fdiv.s, infinity/0"); + expect<float>(0.0, + []{return F::fdiv_s(0.0, numeric_limits<float>::infinity());}, + "fdiv.s, 0/infinity"); + expect<float>(0.0, + []{return F::fdiv_s(numeric_limits<float>::min(), + numeric_limits<float>::max());}, + "fdiv.s, underflow"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fdiv_s(numeric_limits<float>::max(), + numeric_limits<float>::min());}, + "fdiv.s, overflow"); + + // FSQRT.S + expect<float>(0.3, []{return F::fsqrt_s(0.09);}, "fsqrt.s"); + expect<bool>(true, []{ + float fd = F::fsqrt_s(-1.0); + return F::isquietnan(fd); + }, "fsqrt.s, NaN"); + expect<bool>(true, []{ + float fd = F::fsqrt_s(numeric_limits<float>::quiet_NaN()); + return F::isquietnan(fd); + }, "fsqrt.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fsqrt_s(numeric_limits<float>::signaling_NaN()); + return F::isquietnan(fd); + }, "fsqrt.s, signaling NaN"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fsqrt_s(numeric_limits<float>::infinity());}, + "fsqrt.s, infinity"); + + // FSGNJ.S + expect<float>(1.0, []{return F::fsgnj_s(1.0, 25.0);}, "fsgnj.s, ++"); + expect<float>(-1.0, []{return F::fsgnj_s(1.0, -25.0);}, "fsgnj.s, +-"); + expect<float>(1.0, []{return F::fsgnj_s(-1.0, 25.0);}, "fsgnj.s, -+"); + expect<float>(-1.0, []{return F::fsgnj_s(-1.0, -25.0);}, "fsgnj.s, --"); + expect<bool>(true, []{ + float fd = F::fsgnj_s(numeric_limits<float>::quiet_NaN(), -4.0); + return F::isquietnan(fd); + }, "fsgnj.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fsgnj_s(numeric_limits<float>::signaling_NaN(), + -4.0); + return F::issignalingnan(fd); + }, "fsgnj.s, signaling NaN"); + expect<float>(4.0, []{return F::fsgnj_s(4.0, + numeric_limits<float>::quiet_NaN());}, "fsgnj.s, inject NaN"); + expect<float>(-4.0, + []{return F::fsgnj_s(4.0, -numeric_limits<float>::quiet_NaN());}, + "fsgnj.s, inject -NaN"); + + // FSGNJN.S + expect<float>(-1.0, []{return F::fsgnjn_s(1.0, 25.0);}, "fsgnjn.s, ++"); + expect<float>(1.0, []{return F::fsgnjn_s(1.0, -25.0);}, "fsgnjn.s, +-"); + expect<float>(-1.0, []{return F::fsgnjn_s(-1.0, 25.0);}, "fsgnjn.s, -+"); + expect<float>(1.0, []{return F::fsgnjn_s(-1.0, -25.0);}, "fsgnjn.s, --"); + expect<bool>(true, []{ + float fd = F::fsgnjn_s(numeric_limits<float>::quiet_NaN(), -4.0); + return F::isquietnan(fd); + }, "fsgnjn.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fsgnjn_s(numeric_limits<float>::signaling_NaN(), + -4.0); + return F::issignalingnan(fd); + }, "fsgnjn.s, signaling NaN"); + expect<float>(-4.0, + []{return F::fsgnjn_s(4.0, numeric_limits<float>::quiet_NaN());}, + "fsgnjn.s, inject NaN"); + expect<float>(4.0, + []{return F::fsgnjn_s(4.0, -numeric_limits<float>::quiet_NaN());}, + "fsgnjn.s, inject NaN"); + + // FSGNJX.S + expect<float>(1.0, []{return F::fsgnjx_s(1.0, 25.0);}, "fsgnjx.s, ++"); + expect<float>(-1.0, []{return F::fsgnjx_s(1.0, -25.0);}, "fsgnjx.s, +-"); + expect<float>(-1.0, []{return F::fsgnjx_s(-1.0, 25.0);}, "fsgnjx.s, -+"); + expect<float>(1.0, []{return F::fsgnjx_s(-1.0, -25.0);}, "fsgnjx.s, --"); + expect<bool>(true, []{ + float fd = F::fsgnjx_s(numeric_limits<float>::quiet_NaN(), -4.0); + return F::isquietnan(fd); + }, "fsgnjx.s, quiet NaN"); + expect<bool>(true, []{ + float fd = F::fsgnjx_s(numeric_limits<float>::signaling_NaN(), + -4.0); + return F::issignalingnan(fd); + }, "fsgnjx.s, signaling NaN"); + expect<float>(4.0, + []{return F::fsgnjx_s(4.0, numeric_limits<float>::quiet_NaN());}, + "fsgnjx.s, inject NaN"); + expect<float>(-4.0, + []{return F::fsgnjx_s(4.0, -numeric_limits<float>::quiet_NaN());}, + "fsgnjx.s, inject -NaN"); + + // FMIN.S + expect<float>(2.718, []{return F::fmin_s(3.14, 2.718);}, "fmin.s"); + expect<float>(-numeric_limits<float>::infinity(), + []{return F::fmin_s(-numeric_limits<float>::infinity(), + numeric_limits<float>::min());}, + "fmin.s, -infinity"); + expect<float>(numeric_limits<float>::max(), + []{return F::fmin_s(numeric_limits<float>::infinity(), + numeric_limits<float>::max());}, + "fmin.s, infinity"); + expect<float>(-1.414, + []{return F::fmin_s(numeric_limits<float>::quiet_NaN(), -1.414);}, + "fmin.s, quiet NaN first"); + expect<float>(2.718, + []{return F::fmin_s(2.718, numeric_limits<float>::quiet_NaN());}, + "fmin.s, quiet NaN second"); + expect<bool>(true, []{ + float fd = F::fmin_s(numeric_limits<float>::quiet_NaN(), + numeric_limits<float>::quiet_NaN()); + return F::isquietnan(fd); + }, "fmin.s, quiet NaN both"); + expect<float>(3.14, + []{return F::fmin_s(numeric_limits<float>::signaling_NaN(), + 3.14);}, + "fmin.s, signaling NaN first"); + expect<float>(1.816, + []{return F::fmin_s(1.816, + numeric_limits<float>::signaling_NaN());}, + "fmin.s, signaling NaN second"); + expect<bool>(true, []{ + float fd = F::fmin_s(numeric_limits<float>::signaling_NaN(), + numeric_limits<float>::signaling_NaN()); + return F::issignalingnan(fd); + }, "fmin.s, signaling NaN both"); + + // FMAX.S + expect<float>(3.14, []{return F::fmax_s(3.14, 2.718);}, "fmax.s"); + expect<float>(numeric_limits<float>::min(), + []{return F::fmax_s(-numeric_limits<float>::infinity(), + numeric_limits<float>::min());}, + "fmax.s, -infinity"); + expect<float>(numeric_limits<float>::infinity(), + []{return F::fmax_s(numeric_limits<float>::infinity(), + numeric_limits<float>::max());}, + "fmax.s, infinity"); + expect<float>(-1.414, + []{return F::fmax_s(numeric_limits<float>::quiet_NaN(), -1.414);}, + "fmax.s, quiet NaN first"); + expect<float>(2.718, + []{return F::fmax_s(2.718, numeric_limits<float>::quiet_NaN());}, + "fmax.s, quiet NaN second"); + expect<bool>(true, []{ + float fd = F::fmax_s(numeric_limits<float>::quiet_NaN(), + numeric_limits<float>::quiet_NaN()); + return F::isquietnan(fd); + }, "fmax.s, quiet NaN both"); + expect<float>(3.14, + []{return F::fmax_s(numeric_limits<float>::signaling_NaN(), + 3.14);}, + "fmax.s, signaling NaN first"); + expect<float>(1.816, []{return F::fmax_s(1.816, + numeric_limits<float>::signaling_NaN());}, + "fmax.s, signaling NaN second"); + expect<bool>(true, []{ + float fd = F::fmax_s(numeric_limits<float>::signaling_NaN(), + numeric_limits<float>::signaling_NaN()); + return F::issignalingnan(fd); + }, "fmax.s, signaling NaN both"); + + // FCVT.W.S + expect<int64_t>(256, []{return F::fcvt_w_s(256.3);}, + "fcvt.w.s, truncate positive"); + expect<int64_t>(-256, []{return F::fcvt_w_s(-256.2);}, + "fcvt.w.s, truncate negative"); + expect<int64_t>(0, []{return F::fcvt_w_s(0.0);}, "fcvt.w.s, 0.0"); + expect<int64_t>(0, []{return F::fcvt_w_s(-0.0);}, "fcvt.w.s, -0.0"); + expect<int64_t>(numeric_limits<int32_t>::max(), + []{return F::fcvt_w_s(numeric_limits<float>::max());}, + "fcvt.w.s, overflow"); + expect<int64_t>(0, []{return F::fcvt_w_s(numeric_limits<float>::min());}, + "fcvt.w.s, underflow"); + expect<int64_t>(numeric_limits<int32_t>::max(), + []{return F::fcvt_w_s(numeric_limits<float>::infinity());}, + "fcvt.w.s, infinity"); + expect<int64_t>(numeric_limits<int32_t>::min(), + []{return F::fcvt_w_s(-numeric_limits<float>::infinity());}, + "fcvt.w.s, -infinity"); + expect<int64_t>(numeric_limits<int32_t>::max(), + []{return F::fcvt_w_s(numeric_limits<float>::quiet_NaN());}, + "fcvt.w.s, quiet NaN"); + expect<int64_t>(numeric_limits<int32_t>::max(), + []{return F::fcvt_w_s(-numeric_limits<float>::quiet_NaN());}, + "fcvt.w.s, quiet -NaN"); + expect<int64_t>(numeric_limits<int32_t>::max(), + []{return F::fcvt_w_s(numeric_limits<float>::signaling_NaN());}, + "fcvt.w.s, signaling NaN"); + + // FCVT.WU.S + expect<uint64_t>(256, []{return F::fcvt_wu_s(256.3);}, + "fcvt.wu.s, truncate positive"); + expect<uint64_t>(0, []{return F::fcvt_wu_s(-256.2);}, + "fcvt.wu.s, truncate negative"); + expect<uint64_t>(0, []{return F::fcvt_wu_s(0.0);}, "fcvt.wu.s, 0.0"); + expect<uint64_t>(0, []{return F::fcvt_wu_s(-0.0);}, "fcvt.wu.s, -0.0"); + expect<uint64_t>(numeric_limits<uint64_t>::max(), + []{return F::fcvt_wu_s(numeric_limits<float>::max());}, + "fcvt.wu.s, overflow"); + expect<uint64_t>(0, []{return F::fcvt_wu_s(numeric_limits<float>::min());}, + "fcvt.wu.s, underflow"); + expect<uint64_t>(numeric_limits<uint64_t>::max(), + []{return F::fcvt_wu_s(numeric_limits<float>::infinity());}, + "fcvt.wu.s, infinity"); + expect<uint64_t>(0, + []{return F::fcvt_wu_s(-numeric_limits<float>::infinity());}, + "fcvt.wu.s, -infinity"); + expect<uint64_t>(0xFFFFFFFFFFFFFFFFULL, + []{return F::fcvt_wu_s(numeric_limits<float>::quiet_NaN());}, + "fcvt.wu.s, quiet NaN"); + expect<uint64_t>(0xFFFFFFFFFFFFFFFFULL, + []{return F::fcvt_wu_s(-numeric_limits<float>::quiet_NaN());}, + "fcvt.wu.s, quiet -NaN"); + expect<uint64_t>(0xFFFFFFFFFFFFFFFFULL, + []{return F::fcvt_wu_s(numeric_limits<float>::signaling_NaN());}, + "fcvt.wu.s, signaling NaN"); + + // FMV.X.S + expect<uint64_t>(0x000000004048F5C3ULL, []{return F::fmv_x_s(3.14);}, + "fmv.x.s, positive"); + expect<uint64_t>(0xFFFFFFFFC048F5C3ULL, []{return F::fmv_x_s(-3.14);}, + "fmv.x.s, negative"); + expect<uint64_t>(0x0000000000000000ULL, []{return F::fmv_x_s(0.0);}, + "fmv.x.s, 0.0"); + expect<uint64_t>(0xFFFFFFFF80000000ULL, []{return F::fmv_x_s(-0.0);}, + "fmv.x.s, -0.0"); + + // FEQ.S + expect<bool>(true, []{return F::feq_s(1.414, 1.414);}, "feq.s, equal"); + expect<bool>(false, []{return F::feq_s(2.718, 1.816);}, + "feq.s, not equal"); + expect<bool>(true, []{return F::feq_s(0.0, -0.0);}, "feq.s, 0 == -0"); + expect<bool>(false, + []{return F::feq_s(numeric_limits<float>::quiet_NaN(), -1.0);}, + "feq.s, quiet NaN first"); + expect<bool>(false, + []{return F::feq_s(2.0, numeric_limits<float>::quiet_NaN());}, + "feq.s, quiet NaN second"); + expect<bool>(false, + []{return F::feq_s(numeric_limits<float>::quiet_NaN(), + numeric_limits<float>::quiet_NaN());}, + "feq.s, quiet NaN both"); + expect<bool>(false, + []{return F::feq_s(numeric_limits<float>::signaling_NaN(), -1.0);}, + "feq.s, signaling NaN first"); + expect<bool>(false, + []{return F::feq_s(2.0, numeric_limits<float>::signaling_NaN());}, + "feq.s, signaling NaN second"); + expect<bool>(false, + []{return F::feq_s(numeric_limits<float>::signaling_NaN(), + numeric_limits<float>::signaling_NaN());}, + "feq.s, signaling NaN both"); + + // FLT.S + expect<bool>(false, []{return F::flt_s(1.414, 1.414);}, "flt.s, equal"); + expect<bool>(true, []{return F::flt_s(1.816, 2.718);}, "flt.s, less"); + expect<bool>(false, []{return F::flt_s(2.718, 1.816);}, "flt.s, greater"); + expect<bool>(false, + []{return F::flt_s(numeric_limits<float>::quiet_NaN(), -1.0);}, + "flt.s, quiet NaN first"); + expect<bool>(false, + []{return F::flt_s(2.0, numeric_limits<float>::quiet_NaN());}, + "flt.s, quiet NaN second"); + expect<bool>(false, + []{return F::flt_s(numeric_limits<float>::quiet_NaN(), + numeric_limits<float>::quiet_NaN());}, + "flt.s, quiet NaN both"); + expect<bool>(false, + []{return F::flt_s(numeric_limits<float>::signaling_NaN(), -1.0);}, + "flt.s, signaling NaN first"); + expect<bool>(false, + []{return F::flt_s(2.0, numeric_limits<float>::signaling_NaN());}, + "flt.s, signaling NaN second"); + expect<bool>(false, + []{return F::flt_s(numeric_limits<float>::signaling_NaN(), + numeric_limits<float>::signaling_NaN());}, + "flt.s, signaling NaN both"); + + // FLE.S + expect<bool>(true, []{return F::fle_s(1.414, 1.414);}, "fle.s, equal"); + expect<bool>(true, []{return F::fle_s(1.816, 2.718);}, "fle.s, less"); + expect<bool>(false, []{return F::fle_s(2.718, 1.816);}, "fle.s, greater"); + expect<bool>(true, []{return F::fle_s(0.0, -0.0);}, "fle.s, 0 == -0"); + expect<bool>(false, + []{return F::fle_s(numeric_limits<float>::quiet_NaN(), -1.0);}, + "fle.s, quiet NaN first"); + expect<bool>(false, + []{return F::fle_s(2.0, numeric_limits<float>::quiet_NaN());}, + "fle.s, quiet NaN second"); + expect<bool>(false, + []{return F::fle_s(numeric_limits<float>::quiet_NaN(), + numeric_limits<float>::quiet_NaN());}, + "fle.s, quiet NaN both"); + expect<bool>(false, + []{return F::fle_s(numeric_limits<float>::signaling_NaN(), -1.0);}, + "fle.s, signaling NaN first"); + expect<bool>(false, + []{return F::fle_s(2.0, numeric_limits<float>::signaling_NaN());}, + "fle.s, signaling NaN second"); + expect<bool>(false, + []{return F::fle_s(numeric_limits<float>::signaling_NaN(), + numeric_limits<float>::signaling_NaN());}, + "fle.s, signaling NaN both"); + + // FCLASS.S + expect<uint64_t>(0x1, + []{return F::fclass_s(-numeric_limits<float>::infinity());}, + "fclass.s, -infinity"); + expect<uint64_t>(0x2, []{return F::fclass_s(-3.14);}, "fclass.s, -normal"); + expect<uint64_t>(0x4, []{return F::fclass_s(F::number(0x807FFFFF));}, + "fclass.s, -subnormal"); + expect<uint64_t>(0x8, []{return F::fclass_s(-0.0);}, "fclass.s, -0.0"); + expect<uint64_t>(0x10, []{return F::fclass_s(0.0);}, "fclass.s, 0.0"); + expect<uint64_t>(0x20, []{return F::fclass_s(F::number(0x007FFFFF));}, + "fclass.s, subnormal"); + expect<uint64_t>(0x40, []{return F::fclass_s(1.816);}, "fclass.s, normal"); + expect<uint64_t>(0x80, + []{return F::fclass_s(numeric_limits<float>::infinity());}, + "fclass.s, infinity"); + expect<uint64_t>(0x100, + []{return F::fclass_s(numeric_limits<float>::signaling_NaN());}, + "fclass.s, signaling NaN"); + expect<uint64_t>(0x200, + []{return F::fclass_s(numeric_limits<float>::quiet_NaN());}, + "fclass.s, quiet NaN"); + + // FCVT.S.W + expect<float>(0.0, []{return F::fcvt_s_w(0);}, "fcvt.s.w, 0"); + expect<float>(-2147483648.0, + []{return F::fcvt_s_w(numeric_limits<int32_t>::min());}, + "fcvt.s.w, negative"); + expect<float>(255.0, []{return F::fcvt_s_w(0xFFFFFFFF000000FFLL);}, + "fcvt.s.w, truncate"); + + // FCVT.S.WU + expect<float>(0.0, []{return F::fcvt_s_wu(0);}, "fcvt.s.wu, 0"); + expect<float>(2147483648.0, + []{return F::fcvt_s_wu(numeric_limits<int32_t>::min());}, + "fcvt.s.wu"); + expect<float>(255.0, []{return F::fcvt_s_wu(0xFFFFFFFF000000FFLL);}, + "fcvt.s.wu, truncate"); + + // FMV.S.X + expect<float>(numeric_limits<float>::infinity(), + []{return F::fmv_s_x(0x7F800000);}, "fmv.s.x"); + expect<float>(-0.0, []{return F::fmv_s_x(0xFFFFFFFF80000000ULL);}, + "fmv.s.x, truncate"); + + // FCSR functions + int rm = F::frrm(); + expect<uint64_t>(0x7, []{ // FSRM + F::fsrm(-1); + return F::frrm(); + }, "fsrm"); + expect<uint64_t>(0x1F, []{ // FSFLAGS + F::fsflags(0); + F::fsflags(-1); + return F::frflags(); + }, "fsflags"); + expect<uint64_t>(0xFF, []{ // FSCSR + F::fsflags(0); + F::fsrm(0); + F::fscsr(-1); + return F::frcsr(); + }, "fscsr"); + expect<int>(rm << 5, [=]{ + F::fscsr(0); + F::fsrm(rm); + return F::frcsr(); + }, "restore initial round mode"); + + F::fsflags(0); + + // FCVT.L.S + expect<int64_t>(256, []{return F::fcvt_l_s(256.3);}, + "fcvt.l.s, truncate positive"); + expect<int64_t>(-256, []{return F::fcvt_l_s(-256.2);}, + "fcvt.l.s, truncate negative"); + expect<int64_t>(0, []{return F::fcvt_l_s(0.0);}, "fcvt.l.s, 0.0"); + expect<int64_t>(0, []{return F::fcvt_l_s(-0.0);}, "fcvt.l.s, -0.0"); + expect<int64_t>(-8589934592LL, []{return F::fcvt_l_s(-8589934592.0);}, + "fcvt.l.s, 32-bit overflow"); + expect<int64_t>(numeric_limits<int64_t>::max(), + []{return F::fcvt_l_s(numeric_limits<float>::max());}, + "fcvt.l.s, overflow"); + expect<int64_t>(0, []{return F::fcvt_l_s(numeric_limits<float>::min());}, + "fcvt.l.s, underflow"); + expect<int64_t>(numeric_limits<int64_t>::max(), + []{return F::fcvt_l_s(numeric_limits<float>::infinity());}, + "fcvt.l.s, infinity"); + expect<int64_t>(numeric_limits<int64_t>::min(), + []{return F::fcvt_l_s(-numeric_limits<float>::infinity());}, + "fcvt.l.s, -infinity"); + expect<int64_t>(numeric_limits<int64_t>::max(), + []{return F::fcvt_l_s(numeric_limits<float>::quiet_NaN());}, + "fcvt.l.s, quiet NaN"); + expect<int64_t>(numeric_limits<int64_t>::max(), + []{return F::fcvt_l_s(-numeric_limits<float>::quiet_NaN());}, + "fcvt.l.s, quiet -NaN"); + expect<int64_t>(numeric_limits<int64_t>::max(), + []{return F::fcvt_l_s(numeric_limits<float>::signaling_NaN());}, + "fcvt.l.s, signaling NaN"); + + // FCVT.LU.S + expect<uint64_t>(256, []{return F::fcvt_lu_s(256.3);}, + "fcvt.lu.s, truncate positive"); + expect<uint64_t>(0, []{return F::fcvt_lu_s(-256.2);}, + "fcvt.lu.s, truncate negative"); + expect<uint64_t>(0, []{return F::fcvt_lu_s(0.0);}, "fcvt.lu.s, 0.0"); + expect<uint64_t>(0, []{return F::fcvt_lu_s(-0.0);}, "fcvt.lu.s, -0.0"); + expect<uint64_t>(8589934592LL, + []{return F::fcvt_lu_s(8589934592.0);}, + "fcvt.lu.s, 32-bit overflow"); + expect<uint64_t>(numeric_limits<uint64_t>::max(), + []{return F::fcvt_lu_s(numeric_limits<float>::max());}, + "fcvt.lu.s, overflow"); + expect<uint64_t>(0, []{return F::fcvt_lu_s(numeric_limits<float>::min());}, + "fcvt.lu.s, underflow"); + expect<uint64_t>(numeric_limits<uint64_t>::max(), + []{return F::fcvt_lu_s(numeric_limits<float>::infinity());}, + "fcvt.lu.s, infinity"); + expect<uint64_t>(0, + []{return F::fcvt_lu_s(-numeric_limits<float>::infinity());}, + "fcvt.lu.s, -infinity"); + expect<uint64_t>(0xFFFFFFFFFFFFFFFFULL, + []{return F::fcvt_lu_s(numeric_limits<float>::quiet_NaN());}, + "fcvt.lu.s, quiet NaN"); + expect<uint64_t>(0xFFFFFFFFFFFFFFFFULL, + []{return F::fcvt_lu_s(-numeric_limits<float>::quiet_NaN());}, + "fcvt.lu.s, quiet -NaN"); + expect<uint64_t>(0xFFFFFFFFFFFFFFFFULL, + []{return F::fcvt_lu_s(numeric_limits<float>::signaling_NaN());}, + "fcvt.lu.s, signaling NaN"); + + // FCVT.S.L + expect<float>(0.0, []{return F::fcvt_s_l(0);}, "fcvt.s.l, 0"); + expect<float>(-9.223372e18, + []{return F::fcvt_s_l(numeric_limits<int64_t>::min());}, + "fcvt.s.l, negative"); + expect<float>(-4.29496704e9, []{return F::fcvt_s_l(0xFFFFFFFF000000FFLL);}, + "fcvt.s.l, 32-bit truncate"); + + // FCVT.S.LU + expect<float>(0.0, []{return F::fcvt_s_lu(0);}, "fcvt.s.lu, 0"); + expect<float>(9.223372e18, + []{return F::fcvt_s_lu(numeric_limits<int64_t>::min());}, + "fcvt.s.lu"); + expect<float>(1.8446744e19, []{return F::fcvt_s_lu(0xFFFFFFFF000000FFLL);}, + "fcvt.s.lu, 32-bit truncate"); + + return 0; +} |