sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
gem5/tests/test-progs/insttest/src/riscv/rv64f.cpp

695 lines
30 KiB
C++
Raw Normal View History

riscv: [Patch 8/5] Added some regression tests to RISC-V This patch is the eighth patch in a series adding RISC-V to gem5, and third of the bonus patches to the original series of five. It adds some regression tests to RISC-V. Regression tests included: - se/00.hello - se/02.insttest (split into several binaries which are not included due to large size) The tests added to 00.insttest will need to be build manually; to facilitate this, a Makefile is included. The required toolchain and compiler (riscv64-unknown-elf-gcc) can be built from the riscv-tools GitHub repository at https://github.com/riscv/riscv-tools. Note that because EBREAK only makes sense when gdb is running or while in FS mode, it is not included in the linux-rv64i insttest. ERET is not included because it does not make sense in SE mode and, in fact, causes a panic by design. Note also that not every system call is tested in linux-rv64i; of the ones defined in linux/process.hh, some have been given numbers but not definitions for the toolchain, or are merely stubs that always return 0. Of the ones that do work properly, only a subset are tested due to similar functionality. Signed-off by: Alec Roelke Signed-off by: Jason Lowe-Power <jason@lowepower.com>
2016-11-30 23:12:56 +01:00
/*
* 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;
}
Reference in a new issue Copy permalink