AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert "[wasm] fix float to/from int reinterpretation tests"

Browse Source 
This reverts commit e6f7a3470f.

Reason for revert: This appears to be causing failures on linux and arm. E.g., https://logs.chromium.org/logs/v8/buildbucket/cr-buildbucket.appspot.com/8839349751927275456/+/u/Check/bound-functions-serialize and https://ci.chromium.org/ui/p/v8/builders/ci/V8%20Mac%20-%20arm64%20-%20release/5605/overview


Original change's description:
> [wasm] fix float to/from int reinterpretation tests
>
> F32ReinterpretI32 and I32ReinterpretF32 tests don't actually have
> floating point values involved during testing and only use
> integers.
>
> This CL adds FP values as well as fixes the test names to match
> their operation.
>
> Change-Id: I321a7f7af8ae93f6eae4fa263f8e8d0b7bf4d672
> Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3078381
> Reviewed-by: Zhi An Ng <zhin@chromium.org>
> Commit-Queue: Milad Fa <mfarazma@redhat.com>
> Cr-Commit-Position: refs/heads/master@{#76181}

Change-Id: Ie333028bdc7b11f982ac1464bcd8ce1c1ca41657
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3082747
Auto-Submit: Francis McCabe <fgm@chromium.org>
Commit-Queue: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Cr-Commit-Position: refs/heads/master@{#76182}
This commit is contained in:
Francis McCabe 2021-08-09 20:25:00 +00:00 committed by V8 LUCI CQ
parent e6f7a3470f
commit c1f45d816e
5 changed files with 35 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
test/cctest/wasm/test-run-wasm.cc
View File

@ -1053,41 +1053,35 @@ WASM_EXEC_TEST(BrTable_loop_target) {
CHECK_EQ(1, r.Call(0));
}
WASM_EXEC_TEST(I32ReinterpretF32) {
WASM_EXEC_TEST(F32ReinterpretI32) {
WasmRunner<int32_t> r(execution_tier);
float* memory =
r.builder().AddMemoryElems<float>(kWasmPageSize / sizeof(float));
int32_t* memory =
r.builder().AddMemoryElems<int32_t>(kWasmPageSize / sizeof(int32_t));
BUILD(r, WASM_I32_REINTERPRET_F32(
WASM_LOAD_MEM(MachineType::Float32(), WASM_ZERO)));
FOR_FLOAT32_INPUTS(i) {
float input = i;
int32_t expected = bit_cast<int32_t, float>(input);
r.builder().WriteMemory(&memory[0], input);
FOR_INT32_INPUTS(i) {
int32_t expected = i;
r.builder().WriteMemory(&memory[0], expected);
CHECK_EQ(expected, r.Call());
}
}
WASM_EXEC_TEST(F32ReinterpretI32) {
WasmRunner<float> r(execution_tier);
WASM_EXEC_TEST(I32ReinterpretF32) {
WasmRunner<int32_t, int32_t> r(execution_tier);
int32_t* memory =
r.builder().AddMemoryElems<int32_t>(kWasmPageSize / sizeof(int32_t));
BUILD(r, WASM_F32_REINTERPRET_I32(
WASM_LOAD_MEM(MachineType::Int32(), WASM_ZERO)));
BUILD(r,
WASM_STORE_MEM(MachineType::Float32(), WASM_ZERO,
WASM_F32_REINTERPRET_I32(WASM_LOCAL_GET(0))),
WASM_I32V_2(107));
FOR_INT32_INPUTS(i) {
int32_t input = i;
float expected = bit_cast<float, int32_t>(input);
r.builder().WriteMemory(&memory[0], input);
float result = r.Call();
if (std::isnan(expected)) {
CHECK(std::isnan(result));
CHECK(IsSameNan(expected, result));
} else {
CHECK_EQ(expected, result);
}
int32_t expected = i;
CHECK_EQ(107, r.Call(expected));
CHECK_EQ(expected, r.builder().ReadMemory(&memory[0]));
}
}

19
test/cctest/wasm/wasm-run-utils.cc
View File

@ -21,25 +21,6 @@ namespace v8 {
namespace internal {
namespace wasm {
// Helper Functions.
bool IsSameNan(float expected, float actual) {
// Sign is non-deterministic.
uint32_t expected_bits = bit_cast<uint32_t>(expected) & ~0x80000000;
uint32_t actual_bits = bit_cast<uint32_t>(actual) & ~0x80000000;
// Some implementations convert signaling NaNs to quiet NaNs.
return (expected_bits == actual_bits) ||
((expected_bits | 0x00400000) == actual_bits);
}
bool IsSameNan(double expected, double actual) {
// Sign is non-deterministic.
uint64_t expected_bits = bit_cast<uint64_t>(expected) & ~0x8000000000000000;
uint64_t actual_bits = bit_cast<uint64_t>(actual) & ~0x8000000000000000;
// Some implementations convert signaling NaNs to quiet NaNs.
return (expected_bits == actual_bits) ||
((expected_bits | 0x0008000000000000) == actual_bits);
}
TestingModuleBuilder::TestingModuleBuilder(
Zone* zone, ManuallyImportedJSFunction* maybe_import,
TestExecutionTier tier, RuntimeExceptionSupport exception_support,

4
test/cctest/wasm/wasm-run-utils.h
View File

@ -96,10 +96,6 @@ struct ManuallyImportedJSFunction {
Handle<JSFunction> js_function;
};
// Helper Functions.
bool IsSameNan(float expected, float actual);
bool IsSameNan(double expected, double actual);
// A Wasm module builder. Globals are pre-set, however, memory and code may be
// progressively added by a test. In turn, we piecemeal update the runtime
// objects, i.e. {WasmInstanceObject}, {WasmModuleObject} and, if necessary,

18
test/cctest/wasm/wasm-simd-utils.cc
View File

@ -401,6 +401,15 @@ bool IsExtreme(float x) {
(abs_x < kSmallFloatThreshold || abs_x > kLargeFloatThreshold);
}
bool IsSameNan(float expected, float actual) {
// Sign is non-deterministic.
uint32_t expected_bits = bit_cast<uint32_t>(expected) & ~0x80000000;
uint32_t actual_bits = bit_cast<uint32_t>(actual) & ~0x80000000;
// Some implementations convert signaling NaNs to quiet NaNs.
return (expected_bits == actual_bits) ||
((expected_bits | 0x00400000) == actual_bits);
}
bool IsCanonical(float actual) {
uint32_t actual_bits = bit_cast<uint32_t>(actual);
// Canonical NaN has quiet bit and no payload.
@ -565,6 +574,15 @@ bool IsExtreme(double x) {
(abs_x < kSmallFloatThreshold || abs_x > kLargeFloatThreshold);
}
bool IsSameNan(double expected, double actual) {
// Sign is non-deterministic.
uint64_t expected_bits = bit_cast<uint64_t>(expected) & ~0x8000000000000000;
uint64_t actual_bits = bit_cast<uint64_t>(actual) & ~0x8000000000000000;
// Some implementations convert signaling NaNs to quiet NaNs.
return (expected_bits == actual_bits) ||
((expected_bits | 0x0008000000000000) == actual_bits);
}
bool IsCanonical(double actual) {
uint64_t actual_bits = bit_cast<uint64_t>(actual);
// Canonical NaN has quiet bit and no payload.

2
test/cctest/wasm/wasm-simd-utils.h
View File

@ -139,11 +139,13 @@ bool PlatformCanRepresent(T x) {
// Returns true for very small and very large numbers. We skip these test
// values for the approximation instructions, which don't work at the extremes.
bool IsExtreme(float x);
bool IsSameNan(float expected, float actual);
bool IsCanonical(float actual);
void CheckFloatResult(float x, float y, float expected, float actual,
bool exact = true);
bool IsExtreme(double x);
bool IsSameNan(double expected, double actual);
bool IsCanonical(double actual);
void CheckDoubleResult(double x, double y, double expected, double actual,
bool exact = true);