riscv
/
yosys
mirror of https://github.com/YosysHQ/yosys.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
yosys/tests/fmt/fuzz/x_test.cc

45 lines
1.1 KiB
C++
Raw Permalink Normal View History

fmt: fuzz, fix (remove extraneous + incorrect fill) "blk + chunks" is often an overrun, plus the fill is unnecessary; we throw blk away immediately.
2023-06-27 20:51:23 -05:00
#include "fuzztest/fuzztest.h"
#include "gtest/gtest.h"
#include <sstream>
#include "backends/cxxrtl/cxxrtl.h"
#include "libs/bigint/BigUnsigned.hh"
using namespace cxxrtl_yosys;
fmt: merge fuzzers since we don't rely on BigInteger logic This is per fmt's (effective) use, as it turns out, so we're not losing any fidelity in the comparison.
2023-06-27 20:51:24 -05:00
void Formats128BitIntegers(chunk_t x0, chunk_t x1, chunk_t x2, chunk_t x3, bool signed_)
fmt: fuzz, remove some unnecessary busywork Removing some signed checks and logic where we've already guaranteed the values to be positive. Indeed, in these cases, if a negative value got through (per my realisation in the signed fuzz harness), it would cause an infinite loop due to flooring division.
2023-06-27 20:51:24 -05:00
{
// Compare output to BigUnsigned.
fmt: fuzz, fix (remove extraneous + incorrect fill) "blk + chunks" is often an overrun, plus the fill is unnecessary; we throw blk away immediately.
2023-06-27 20:51:23 -05:00
value<128> v;
fmt: fuzz, remove some unnecessary busywork Removing some signed checks and logic where we've already guaranteed the values to be positive. Indeed, in these cases, if a negative value got through (per my realisation in the signed fuzz harness), it would cause an infinite loop due to flooring division.
2023-06-27 20:51:24 -05:00
v = v.blit<127, 64>(value<64>{x1, x0});
v = v.blit<63, 0>(value<64>{x3, x2});
fmt: fuzz, fix (remove extraneous + incorrect fill) "blk + chunks" is often an overrun, plus the fill is unnecessary; we throw blk away immediately.
2023-06-27 20:51:23 -05:00
std::ostringstream oss;
fmt: merge fuzzers since we don't rely on BigInteger logic This is per fmt's (effective) use, as it turns out, so we're not losing any fidelity in the comparison.
2023-06-27 20:51:24 -05:00
oss << value_formatted<128>(v, false, false, ' ', 0, 10, signed_, false, false);
fmt: fuzz, fix (remove extraneous + incorrect fill) "blk + chunks" is often an overrun, plus the fill is unnecessary; we throw blk away immediately.
2023-06-27 20:51:23 -05:00
auto actual = oss.str();
fmt: fuzz, remove some unnecessary busywork Removing some signed checks and logic where we've already guaranteed the values to be positive. Indeed, in these cases, if a negative value got through (per my realisation in the signed fuzz harness), it would cause an infinite loop due to flooring division.
2023-06-27 20:51:24 -05:00
BigUnsigned u;
fmt: merge fuzzers since we don't rely on BigInteger logic This is per fmt's (effective) use, as it turns out, so we're not losing any fidelity in the comparison.
2023-06-27 20:51:24 -05:00
bool negative = signed_ && v.is_neg();
fmt: fuzz, remove some unnecessary busywork Removing some signed checks and logic where we've already guaranteed the values to be positive. Indeed, in these cases, if a negative value got through (per my realisation in the signed fuzz harness), it would cause an infinite loop due to flooring division.
2023-06-27 20:51:24 -05:00
if (negative)
v = v.neg();
u.bitShiftLeft(v.slice<127, 64>().val().get<uint64_t>(), 64);
u.bitOr(u, v.slice<63, 0>().val().get<uint64_t>());
std::string expected;
fmt: merge fuzzers since we don't rely on BigInteger logic This is per fmt's (effective) use, as it turns out, so we're not losing any fidelity in the comparison.
2023-06-27 20:51:24 -05:00
fmt: fuzz, remove some unnecessary busywork Removing some signed checks and logic where we've already guaranteed the values to be positive. Indeed, in these cases, if a negative value got through (per my realisation in the signed fuzz harness), it would cause an infinite loop due to flooring division.
2023-06-27 20:51:24 -05:00
if (u.isZero()) {
expected = "0";
} else {
while (!u.isZero()) {
expected += '0' + (u % 10).toInt();
u /= 10;
}
fmt: merge fuzzers since we don't rely on BigInteger logic This is per fmt's (effective) use, as it turns out, so we're not losing any fidelity in the comparison.
2023-06-27 20:51:24 -05:00
if (negative)
fmt: fuzz, remove some unnecessary busywork Removing some signed checks and logic where we've already guaranteed the values to be positive. Indeed, in these cases, if a negative value got through (per my realisation in the signed fuzz harness), it would cause an infinite loop due to flooring division.
2023-06-27 20:51:24 -05:00
expected += '-';
std::reverse(expected.begin(), expected.end());
}
EXPECT_EQ(actual, expected);
}
fmt: merge fuzzers since we don't rely on BigInteger logic This is per fmt's (effective) use, as it turns out, so we're not losing any fidelity in the comparison.
2023-06-27 20:51:24 -05:00
FUZZ_TEST(CxxrtlDivisionFuzz, Formats128BitIntegers);