7322f0a3c0
Clean up src/wasm and test/ Bug: v8:11074 Change-Id: I1b3d3475a0fbfafe75bb49acfd851f8bd5af5182 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2519183 Reviewed-by: Clemens Backes <clemensb@chromium.org> Commit-Queue: Zhi An Ng <zhin@chromium.org> Cr-Commit-Position: refs/heads/master@{#71025}
939 lines
36 KiB
C++
939 lines
36 KiB
C++
// Copyright 2014 the V8 project authors. All rights reserved. Use of this
|
|
// source code is governed by a BSD-style license that can be found in the
|
|
// LICENSE file.
|
|
|
|
#include "src/codegen/external-reference.h"
|
|
#include "src/objects/objects-inl.h"
|
|
#include "src/wasm/wasm-external-refs.h"
|
|
#include "test/cctest/cctest.h"
|
|
#include "test/cctest/compiler/codegen-tester.h"
|
|
#include "test/cctest/compiler/value-helper.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace compiler {
|
|
|
|
template <typename InType, typename OutType, typename Iterable>
|
|
void TestExternalReference_ConvertOp(
|
|
BufferedRawMachineAssemblerTester<int32_t>* m, ExternalReference ref,
|
|
void (*wrapper)(Address), Iterable inputs) {
|
|
constexpr size_t kBufferSize = std::max(sizeof(InType), sizeof(OutType));
|
|
uint8_t buffer[kBufferSize] = {0};
|
|
Address buffer_addr = reinterpret_cast<Address>(buffer);
|
|
|
|
Node* function = m->ExternalConstant(ref);
|
|
m->CallCFunction(
|
|
function, MachineType::Pointer(),
|
|
std::make_pair(MachineType::Pointer(), m->PointerConstant(buffer)));
|
|
m->Return(m->Int32Constant(4356));
|
|
|
|
for (InType input : inputs) {
|
|
WriteUnalignedValue<InType>(buffer_addr, input);
|
|
|
|
CHECK_EQ(4356, m->Call());
|
|
OutType output = ReadUnalignedValue<OutType>(buffer_addr);
|
|
|
|
WriteUnalignedValue<InType>(buffer_addr, input);
|
|
wrapper(buffer_addr);
|
|
OutType expected_output = ReadUnalignedValue<OutType>(buffer_addr);
|
|
|
|
CHECK_EQ(expected_output, output);
|
|
}
|
|
}
|
|
|
|
template <typename InType, typename OutType, typename Iterable>
|
|
void TestExternalReference_ConvertOpWithOutputAndReturn(
|
|
BufferedRawMachineAssemblerTester<int32_t>* m, ExternalReference ref,
|
|
int32_t (*wrapper)(Address), Iterable inputs) {
|
|
constexpr size_t kBufferSize = std::max(sizeof(InType), sizeof(OutType));
|
|
uint8_t buffer[kBufferSize] = {0};
|
|
Address buffer_addr = reinterpret_cast<Address>(buffer);
|
|
|
|
Node* function = m->ExternalConstant(ref);
|
|
m->Return(m->CallCFunction(
|
|
function, MachineType::Int32(),
|
|
std::make_pair(MachineType::Pointer(), m->PointerConstant(buffer))));
|
|
|
|
for (InType input : inputs) {
|
|
WriteUnalignedValue<InType>(buffer_addr, input);
|
|
|
|
int32_t ret = m->Call();
|
|
OutType output = ReadUnalignedValue<OutType>(buffer_addr);
|
|
|
|
WriteUnalignedValue<InType>(buffer_addr, input);
|
|
int32_t expected_ret = wrapper(buffer_addr);
|
|
OutType expected_output = ReadUnalignedValue<OutType>(buffer_addr);
|
|
|
|
CHECK_EQ(expected_ret, ret);
|
|
CHECK_EQ(expected_output, output);
|
|
}
|
|
}
|
|
|
|
template <typename InType, typename OutType, typename Iterable>
|
|
void TestExternalReference_ConvertOpWithReturn(
|
|
BufferedRawMachineAssemblerTester<OutType>* m, ExternalReference ref,
|
|
OutType (*wrapper)(Address), Iterable inputs) {
|
|
constexpr size_t kBufferSize = sizeof(InType);
|
|
uint8_t buffer[kBufferSize] = {0};
|
|
Address buffer_addr = reinterpret_cast<Address>(buffer);
|
|
|
|
Node* function = m->ExternalConstant(ref);
|
|
m->Return(m->CallCFunction(
|
|
function, MachineType::Int32(),
|
|
std::make_pair(MachineType::Pointer(), m->PointerConstant(buffer))));
|
|
|
|
for (InType input : inputs) {
|
|
WriteUnalignedValue<InType>(buffer_addr, input);
|
|
|
|
OutType ret = m->Call();
|
|
|
|
WriteUnalignedValue<InType>(buffer_addr, input);
|
|
OutType expected_ret = wrapper(buffer_addr);
|
|
|
|
CHECK_EQ(expected_ret, ret);
|
|
}
|
|
}
|
|
|
|
template <typename Type>
|
|
bool isnan(Type value) {
|
|
return false;
|
|
}
|
|
template <>
|
|
bool isnan<float>(float value) {
|
|
return std::isnan(value);
|
|
}
|
|
template <>
|
|
bool isnan<double>(double value) {
|
|
return std::isnan(value);
|
|
}
|
|
|
|
template <typename Type, typename Iterable>
|
|
void TestExternalReference_UnOp(BufferedRawMachineAssemblerTester<int32_t>* m,
|
|
ExternalReference ref, void (*wrapper)(Address),
|
|
Iterable inputs) {
|
|
constexpr size_t kBufferSize = sizeof(Type);
|
|
uint8_t buffer[kBufferSize] = {0};
|
|
Address buffer_addr = reinterpret_cast<Address>(buffer);
|
|
|
|
Node* function = m->ExternalConstant(ref);
|
|
m->CallCFunction(
|
|
function, MachineType::Int32(),
|
|
std::make_pair(MachineType::Pointer(), m->PointerConstant(buffer)));
|
|
m->Return(m->Int32Constant(4356));
|
|
|
|
for (Type input : inputs) {
|
|
WriteUnalignedValue<Type>(buffer_addr, input);
|
|
CHECK_EQ(4356, m->Call());
|
|
Type output = ReadUnalignedValue<Type>(buffer_addr);
|
|
|
|
WriteUnalignedValue<Type>(buffer_addr, input);
|
|
wrapper(buffer_addr);
|
|
Type expected_output = ReadUnalignedValue<Type>(buffer_addr);
|
|
|
|
if (isnan(expected_output) && isnan(output)) continue;
|
|
CHECK_EQ(expected_output, output);
|
|
}
|
|
}
|
|
|
|
template <typename Type, typename Iterable>
|
|
void TestExternalReference_BinOp(BufferedRawMachineAssemblerTester<int32_t>* m,
|
|
ExternalReference ref,
|
|
void (*wrapper)(Address), Iterable inputs) {
|
|
constexpr size_t kBufferSize = 2 * sizeof(Type);
|
|
uint8_t buffer[kBufferSize] = {0};
|
|
Address buffer_addr = reinterpret_cast<Address>(buffer);
|
|
|
|
Node* function = m->ExternalConstant(ref);
|
|
m->CallCFunction(
|
|
function, MachineType::Int32(),
|
|
std::make_pair(MachineType::Pointer(), m->PointerConstant(buffer)));
|
|
m->Return(m->Int32Constant(4356));
|
|
|
|
for (Type input1 : inputs) {
|
|
for (Type input2 : inputs) {
|
|
WriteUnalignedValue<Type>(buffer_addr, input1);
|
|
WriteUnalignedValue<Type>(buffer_addr + sizeof(Type), input2);
|
|
CHECK_EQ(4356, m->Call());
|
|
Type output = ReadUnalignedValue<Type>(buffer_addr);
|
|
|
|
WriteUnalignedValue<Type>(buffer_addr, input1);
|
|
WriteUnalignedValue<Type>(buffer_addr + sizeof(Type), input2);
|
|
wrapper(buffer_addr);
|
|
Type expected_output = ReadUnalignedValue<Type>(buffer_addr);
|
|
|
|
if (isnan(expected_output) && isnan(output)) continue;
|
|
CHECK_EQ(expected_output, output);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename Type, typename Iterable>
|
|
void TestExternalReference_BinOpWithReturn(
|
|
BufferedRawMachineAssemblerTester<int32_t>* m, ExternalReference ref,
|
|
int32_t (*wrapper)(Address), Iterable inputs) {
|
|
constexpr size_t kBufferSize = 2 * sizeof(Type);
|
|
uint8_t buffer[kBufferSize] = {0};
|
|
Address buffer_addr = reinterpret_cast<Address>(buffer);
|
|
|
|
Node* function = m->ExternalConstant(ref);
|
|
m->Return(m->CallCFunction(
|
|
function, MachineType::Int32(),
|
|
std::make_pair(MachineType::Pointer(), m->PointerConstant(buffer))));
|
|
|
|
for (Type input1 : inputs) {
|
|
for (Type input2 : inputs) {
|
|
WriteUnalignedValue<Type>(buffer_addr, input1);
|
|
WriteUnalignedValue<Type>(buffer_addr + sizeof(Type), input2);
|
|
int32_t ret = m->Call();
|
|
Type output = ReadUnalignedValue<Type>(buffer_addr);
|
|
|
|
WriteUnalignedValue<Type>(buffer_addr, input1);
|
|
WriteUnalignedValue<Type>(buffer_addr + sizeof(Type), input2);
|
|
int32_t expected_ret = wrapper(buffer_addr);
|
|
Type expected_output = ReadUnalignedValue<Type>(buffer_addr);
|
|
|
|
CHECK_EQ(expected_ret, ret);
|
|
if (isnan(expected_output) && isnan(output)) continue;
|
|
CHECK_EQ(expected_output, output);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(RunCallF32Trunc) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f32_trunc();
|
|
TestExternalReference_UnOp<float>(&m, ref, wasm::f32_trunc_wrapper,
|
|
ValueHelper::float32_vector());
|
|
}
|
|
|
|
TEST(RunCallF32Floor) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f32_floor();
|
|
TestExternalReference_UnOp<float>(&m, ref, wasm::f32_floor_wrapper,
|
|
ValueHelper::float32_vector());
|
|
}
|
|
|
|
TEST(RunCallF32Ceil) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f32_ceil();
|
|
TestExternalReference_UnOp<float>(&m, ref, wasm::f32_ceil_wrapper,
|
|
ValueHelper::float32_vector());
|
|
}
|
|
|
|
TEST(RunCallF32RoundTiesEven) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f32_nearest_int();
|
|
TestExternalReference_UnOp<float>(&m, ref, wasm::f32_nearest_int_wrapper,
|
|
ValueHelper::float32_vector());
|
|
}
|
|
|
|
TEST(RunCallF64Trunc) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f64_trunc();
|
|
TestExternalReference_UnOp<double>(&m, ref, wasm::f64_trunc_wrapper,
|
|
ValueHelper::float64_vector());
|
|
}
|
|
|
|
TEST(RunCallF64Floor) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f64_floor();
|
|
TestExternalReference_UnOp<double>(&m, ref, wasm::f64_floor_wrapper,
|
|
ValueHelper::float64_vector());
|
|
}
|
|
|
|
TEST(RunCallF64Ceil) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f64_ceil();
|
|
TestExternalReference_UnOp<double>(&m, ref, wasm::f64_ceil_wrapper,
|
|
ValueHelper::float64_vector());
|
|
}
|
|
|
|
TEST(RunCallF64RoundTiesEven) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_f64_nearest_int();
|
|
TestExternalReference_UnOp<double>(&m, ref, wasm::f64_nearest_int_wrapper,
|
|
ValueHelper::float64_vector());
|
|
}
|
|
|
|
TEST(RunCallInt64ToFloat32) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_int64_to_float32();
|
|
TestExternalReference_ConvertOp<int64_t, float>(
|
|
&m, ref, wasm::int64_to_float32_wrapper, ValueHelper::int64_vector());
|
|
}
|
|
|
|
TEST(RunCallUint64ToFloat32) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_uint64_to_float32();
|
|
TestExternalReference_ConvertOp<uint64_t, float>(
|
|
&m, ref, wasm::uint64_to_float32_wrapper, ValueHelper::uint64_vector());
|
|
}
|
|
|
|
TEST(RunCallInt64ToFloat64) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_int64_to_float64();
|
|
TestExternalReference_ConvertOp<int64_t, double>(
|
|
&m, ref, wasm::int64_to_float64_wrapper, ValueHelper::int64_vector());
|
|
}
|
|
|
|
TEST(RunCallUint64ToFloat64) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_uint64_to_float64();
|
|
TestExternalReference_ConvertOp<uint64_t, double>(
|
|
&m, ref, wasm::uint64_to_float64_wrapper, ValueHelper::uint64_vector());
|
|
}
|
|
|
|
TEST(RunCallFloat32ToInt64) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_float32_to_int64();
|
|
TestExternalReference_ConvertOpWithOutputAndReturn<float, int64_t>(
|
|
&m, ref, wasm::float32_to_int64_wrapper, ValueHelper::float32_vector());
|
|
}
|
|
|
|
TEST(RunCallFloat32ToUint64) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_float32_to_uint64();
|
|
TestExternalReference_ConvertOpWithOutputAndReturn<float, uint64_t>(
|
|
&m, ref, wasm::float32_to_uint64_wrapper, ValueHelper::float32_vector());
|
|
}
|
|
|
|
TEST(RunCallFloat64ToInt64) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_float64_to_int64();
|
|
TestExternalReference_ConvertOpWithOutputAndReturn<double, int64_t>(
|
|
&m, ref, wasm::float64_to_int64_wrapper, ValueHelper::float64_vector());
|
|
}
|
|
|
|
TEST(RunCallFloat64ToUint64) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_float64_to_uint64();
|
|
TestExternalReference_ConvertOpWithOutputAndReturn<double, uint64_t>(
|
|
&m, ref, wasm::float64_to_uint64_wrapper, ValueHelper::float64_vector());
|
|
}
|
|
|
|
TEST(RunCallInt64Div) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_int64_div();
|
|
TestExternalReference_BinOpWithReturn<int64_t>(
|
|
&m, ref, wasm::int64_div_wrapper, ValueHelper::int64_vector());
|
|
}
|
|
|
|
TEST(RunCallInt64Mod) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_int64_mod();
|
|
TestExternalReference_BinOpWithReturn<int64_t>(
|
|
&m, ref, wasm::int64_mod_wrapper, ValueHelper::int64_vector());
|
|
}
|
|
|
|
TEST(RunCallUint64Div) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_uint64_div();
|
|
TestExternalReference_BinOpWithReturn<uint64_t>(
|
|
&m, ref, wasm::uint64_div_wrapper, ValueHelper::uint64_vector());
|
|
}
|
|
|
|
TEST(RunCallUint64Mod) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_uint64_mod();
|
|
TestExternalReference_BinOpWithReturn<uint64_t>(
|
|
&m, ref, wasm::uint64_mod_wrapper, ValueHelper::uint64_vector());
|
|
}
|
|
|
|
TEST(RunCallWord32Ctz) {
|
|
BufferedRawMachineAssemblerTester<uint32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_word32_ctz();
|
|
TestExternalReference_ConvertOpWithReturn<int32_t, uint32_t>(
|
|
&m, ref, wasm::word32_ctz_wrapper, ValueHelper::int32_vector());
|
|
}
|
|
|
|
TEST(RunCallWord64Ctz) {
|
|
BufferedRawMachineAssemblerTester<uint32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_word64_ctz();
|
|
TestExternalReference_ConvertOpWithReturn<int64_t, uint32_t>(
|
|
&m, ref, wasm::word64_ctz_wrapper, ValueHelper::int64_vector());
|
|
}
|
|
|
|
TEST(RunCallWord32Popcnt) {
|
|
BufferedRawMachineAssemblerTester<uint32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_word32_popcnt();
|
|
TestExternalReference_ConvertOpWithReturn<uint32_t, uint32_t>(
|
|
&m, ref, wasm::word32_popcnt_wrapper, ValueHelper::int32_vector());
|
|
}
|
|
|
|
TEST(RunCallWord64Popcnt) {
|
|
BufferedRawMachineAssemblerTester<uint32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_word64_popcnt();
|
|
TestExternalReference_ConvertOpWithReturn<int64_t, uint32_t>(
|
|
&m, ref, wasm::word64_popcnt_wrapper, ValueHelper::int64_vector());
|
|
}
|
|
|
|
TEST(RunCallFloat64Pow) {
|
|
BufferedRawMachineAssemblerTester<int32_t> m;
|
|
ExternalReference ref = ExternalReference::wasm_float64_pow();
|
|
TestExternalReference_BinOp<double>(&m, ref, wasm::float64_pow_wrapper,
|
|
ValueHelper::float64_vector());
|
|
}
|
|
|
|
#ifdef V8_ENABLE_FP_PARAMS_IN_C_LINKAGE
|
|
|
|
template <typename T>
|
|
MachineType MachineTypeForCType() {
|
|
UNREACHABLE();
|
|
}
|
|
|
|
template <>
|
|
MachineType MachineTypeForCType<int32_t>() {
|
|
return MachineType::Int32();
|
|
}
|
|
|
|
template <>
|
|
MachineType MachineTypeForCType<double>() {
|
|
return MachineType::Float64();
|
|
}
|
|
|
|
template <>
|
|
MachineType MachineTypeForCType<float>() {
|
|
return MachineType::Float32();
|
|
}
|
|
|
|
#define SIGNATURE_TYPES_END(TYPE, IDX, VALUE) MachineTypeForCType<TYPE>()
|
|
#define SIGNATURE_TYPES(TYPE, IDX, VALUE) SIGNATURE_TYPES_END(TYPE, IDX, VALUE),
|
|
|
|
#define PARAM_PAIRS_END(TYPE, IDX, VALUE) \
|
|
std::make_pair(MachineTypeForCType<TYPE>(), m.Parameter(IDX))
|
|
|
|
#define PARAM_PAIRS(TYPE, IDX, VALUE) PARAM_PAIRS_END(TYPE, IDX, VALUE),
|
|
|
|
#define CALL_ARGS_END(TYPE, IDX, VALUE) static_cast<TYPE>(VALUE)
|
|
#define CALL_ARGS(TYPE, IDX, VALUE) CALL_ARGS_END(TYPE, IDX, VALUE),
|
|
|
|
#define COMPARE_ARG_I_END(TYPE, IDX, VALUE) (arg##IDX == VALUE)
|
|
#define COMPARE_ARG_I(TYPE, IDX, VALUE) COMPARE_ARG_I_END(TYPE, IDX, VALUE)&&
|
|
|
|
#define SIGNATURE_TEST(NAME, SIGNATURE, FUNC) \
|
|
TEST(NAME) { \
|
|
RawMachineAssemblerTester<int64_t> m(SIGNATURE(SIGNATURE_TYPES)); \
|
|
\
|
|
Address func_address = FUNCTION_ADDR(&FUNC); \
|
|
ExternalReference::Type dummy_type = ExternalReference::BUILTIN_CALL; \
|
|
ApiFunction func(func_address); \
|
|
ExternalReference ref = ExternalReference::Create(&func, dummy_type); \
|
|
\
|
|
Node* function = m.ExternalConstant(ref); \
|
|
m.Return(m.CallCFunction(function, MachineType::Int64(), \
|
|
SIGNATURE(PARAM_PAIRS))); \
|
|
\
|
|
int64_t c = m.Call(SIGNATURE(CALL_ARGS)); \
|
|
CHECK_EQ(c, 42); \
|
|
}
|
|
|
|
#define MIXED_SIGNATURE_SIMPLE(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(double, 1, 1.5) \
|
|
V##_END(int32_t, 2, 2)
|
|
|
|
int64_t test_api_func_simple(int32_t arg0, double arg1, int32_t arg2) {
|
|
CHECK(MIXED_SIGNATURE_SIMPLE(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureSimple, MIXED_SIGNATURE_SIMPLE,
|
|
test_api_func_simple)
|
|
|
|
#define MIXED_SIGNATURE(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(double, 1, 1.5) \
|
|
V(int32_t, 2, 2) \
|
|
V(double, 3, 3.5) \
|
|
V(int32_t, 4, 4) \
|
|
V(double, 5, 5.5) \
|
|
V(int32_t, 6, 6) \
|
|
V(double, 7, 7.5) \
|
|
V(int32_t, 8, 8) \
|
|
V(double, 9, 9.5) \
|
|
V##_END(int32_t, 10, 10)
|
|
|
|
int64_t test_api_func(int32_t arg0, double arg1, int32_t arg2, double arg3,
|
|
int32_t arg4, double arg5, int32_t arg6, double arg7,
|
|
int32_t arg8, double arg9, int32_t arg10) {
|
|
CHECK(MIXED_SIGNATURE(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignature, MIXED_SIGNATURE, test_api_func)
|
|
|
|
#define MIXED_SIGNATURE_DOUBLE_INT(V) \
|
|
V(double, 0, 0.5) \
|
|
V(double, 1, 1.5) \
|
|
V(double, 2, 2.5) \
|
|
V(double, 3, 3.5) \
|
|
V(double, 4, 4.5) \
|
|
V(double, 5, 5.5) \
|
|
V(double, 6, 6.5) \
|
|
V(double, 7, 7.5) \
|
|
V(double, 8, 8.5) \
|
|
V(double, 9, 9.5) \
|
|
V(int32_t, 10, 10) \
|
|
V(int32_t, 11, 11) \
|
|
V(int32_t, 12, 12) \
|
|
V(int32_t, 13, 13) \
|
|
V(int32_t, 14, 14) \
|
|
V(int32_t, 15, 15) \
|
|
V(int32_t, 16, 16) \
|
|
V(int32_t, 17, 17) \
|
|
V(int32_t, 18, 18) \
|
|
V##_END(int32_t, 19, 19)
|
|
|
|
int64_t func_mixed_double_int(double arg0, double arg1, double arg2,
|
|
double arg3, double arg4, double arg5,
|
|
double arg6, double arg7, double arg8,
|
|
double arg9, int32_t arg10, int32_t arg11,
|
|
int32_t arg12, int32_t arg13, int32_t arg14,
|
|
int32_t arg15, int32_t arg16, int32_t arg17,
|
|
int32_t arg18, int32_t arg19) {
|
|
CHECK(MIXED_SIGNATURE_DOUBLE_INT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureDoubleInt, MIXED_SIGNATURE_DOUBLE_INT,
|
|
func_mixed_double_int)
|
|
|
|
#define MIXED_SIGNATURE_INT_DOUBLE(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(int32_t, 1, 1) \
|
|
V(int32_t, 2, 2) \
|
|
V(int32_t, 3, 3) \
|
|
V(int32_t, 4, 4) \
|
|
V(int32_t, 5, 5) \
|
|
V(int32_t, 6, 6) \
|
|
V(int32_t, 7, 7) \
|
|
V(int32_t, 8, 8) \
|
|
V(int32_t, 9, 9) \
|
|
V(double, 10, 10.5) \
|
|
V(double, 11, 11.5) \
|
|
V(double, 12, 12.5) \
|
|
V(double, 13, 13.5) \
|
|
V(double, 14, 14.5) \
|
|
V(double, 15, 15.5) \
|
|
V(double, 16, 16.5) \
|
|
V(double, 17, 17.5) \
|
|
V(double, 18, 18.5) \
|
|
V##_END(double, 19, 19.5)
|
|
|
|
int64_t func_mixed_int_double(int32_t arg0, int32_t arg1, int32_t arg2,
|
|
int32_t arg3, int32_t arg4, int32_t arg5,
|
|
int32_t arg6, int32_t arg7, int32_t arg8,
|
|
int32_t arg9, double arg10, double arg11,
|
|
double arg12, double arg13, double arg14,
|
|
double arg15, double arg16, double arg17,
|
|
double arg18, double arg19) {
|
|
CHECK(MIXED_SIGNATURE_INT_DOUBLE(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureIntDouble, MIXED_SIGNATURE_INT_DOUBLE,
|
|
func_mixed_int_double)
|
|
|
|
#define MIXED_SIGNATURE_INT_DOUBLE_ALT(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(double, 1, 1.5) \
|
|
V(int32_t, 2, 2) \
|
|
V(double, 3, 3.5) \
|
|
V(int32_t, 4, 4) \
|
|
V(double, 5, 5.5) \
|
|
V(int32_t, 6, 6) \
|
|
V(double, 7, 7.5) \
|
|
V(int32_t, 8, 8) \
|
|
V(double, 9, 9.5) \
|
|
V(int32_t, 10, 10) \
|
|
V(double, 11, 11.5) \
|
|
V(int32_t, 12, 12) \
|
|
V(double, 13, 13.5) \
|
|
V(int32_t, 14, 14) \
|
|
V(double, 15, 15.5) \
|
|
V(int32_t, 16, 16) \
|
|
V(double, 17, 17.5) \
|
|
V(int32_t, 18, 18) \
|
|
V##_END(double, 19, 19.5)
|
|
|
|
int64_t func_mixed_int_double_alt(int32_t arg0, double arg1, int32_t arg2,
|
|
double arg3, int32_t arg4, double arg5,
|
|
int32_t arg6, double arg7, int32_t arg8,
|
|
double arg9, int32_t arg10, double arg11,
|
|
int32_t arg12, double arg13, int32_t arg14,
|
|
double arg15, int32_t arg16, double arg17,
|
|
int32_t arg18, double arg19) {
|
|
CHECK(MIXED_SIGNATURE_INT_DOUBLE_ALT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureIntDoubleAlt,
|
|
MIXED_SIGNATURE_INT_DOUBLE_ALT, func_mixed_int_double_alt)
|
|
|
|
#define SIGNATURE_ONLY_DOUBLE(V) \
|
|
V(double, 0, 0.5) \
|
|
V(double, 1, 1.5) \
|
|
V(double, 2, 2.5) \
|
|
V(double, 3, 3.5) \
|
|
V(double, 4, 4.5) \
|
|
V(double, 5, 5.5) \
|
|
V(double, 6, 6.5) \
|
|
V(double, 7, 7.5) \
|
|
V(double, 8, 8.5) \
|
|
V##_END(double, 9, 9.5)
|
|
|
|
int64_t func_only_double(double arg0, double arg1, double arg2, double arg3,
|
|
double arg4, double arg5, double arg6, double arg7,
|
|
double arg8, double arg9) {
|
|
CHECK(SIGNATURE_ONLY_DOUBLE(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithSignatureOnlyDouble, SIGNATURE_ONLY_DOUBLE,
|
|
func_only_double)
|
|
|
|
#define SIGNATURE_ONLY_DOUBLE_20(V) \
|
|
V(double, 0, 0.5) \
|
|
V(double, 1, 1.5) \
|
|
V(double, 2, 2.5) \
|
|
V(double, 3, 3.5) \
|
|
V(double, 4, 4.5) \
|
|
V(double, 5, 5.5) \
|
|
V(double, 6, 6.5) \
|
|
V(double, 7, 7.5) \
|
|
V(double, 8, 8.5) \
|
|
V(double, 9, 9.5) \
|
|
V(double, 10, 10.5) \
|
|
V(double, 11, 11.5) \
|
|
V(double, 12, 12.5) \
|
|
V(double, 13, 13.5) \
|
|
V(double, 14, 14.5) \
|
|
V(double, 15, 15.5) \
|
|
V(double, 16, 16.5) \
|
|
V(double, 17, 17.5) \
|
|
V(double, 18, 18.5) \
|
|
V##_END(double, 19, 19.5)
|
|
|
|
int64_t func_only_double_20(double arg0, double arg1, double arg2, double arg3,
|
|
double arg4, double arg5, double arg6, double arg7,
|
|
double arg8, double arg9, double arg10,
|
|
double arg11, double arg12, double arg13,
|
|
double arg14, double arg15, double arg16,
|
|
double arg17, double arg18, double arg19) {
|
|
CHECK(SIGNATURE_ONLY_DOUBLE_20(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithSignatureOnlyDouble20, SIGNATURE_ONLY_DOUBLE_20,
|
|
func_only_double_20)
|
|
|
|
#define SIGNATURE_ONLY_INT(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(int32_t, 1, 1) \
|
|
V(int32_t, 2, 2) \
|
|
V(int32_t, 3, 3) \
|
|
V(int32_t, 4, 4) \
|
|
V(int32_t, 5, 5) \
|
|
V(int32_t, 6, 6) \
|
|
V(int32_t, 7, 7) \
|
|
V(int32_t, 8, 8) \
|
|
V##_END(int32_t, 9, 9)
|
|
|
|
int64_t func_only_int(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3,
|
|
int32_t arg4, int32_t arg5, int32_t arg6, int32_t arg7,
|
|
int32_t arg8, int32_t arg9) {
|
|
CHECK(SIGNATURE_ONLY_INT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithSignatureOnlyInt, SIGNATURE_ONLY_INT, func_only_int)
|
|
|
|
#define SIGNATURE_ONLY_INT_20(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(int32_t, 1, 1) \
|
|
V(int32_t, 2, 2) \
|
|
V(int32_t, 3, 3) \
|
|
V(int32_t, 4, 4) \
|
|
V(int32_t, 5, 5) \
|
|
V(int32_t, 6, 6) \
|
|
V(int32_t, 7, 7) \
|
|
V(int32_t, 8, 8) \
|
|
V(int32_t, 9, 9) \
|
|
V(int32_t, 10, 10) \
|
|
V(int32_t, 11, 11) \
|
|
V(int32_t, 12, 12) \
|
|
V(int32_t, 13, 13) \
|
|
V(int32_t, 14, 14) \
|
|
V(int32_t, 15, 15) \
|
|
V(int32_t, 16, 16) \
|
|
V(int32_t, 17, 17) \
|
|
V(int32_t, 18, 18) \
|
|
V##_END(int32_t, 19, 19)
|
|
|
|
int64_t func_only_int_20(int32_t arg0, int32_t arg1, int32_t arg2, int32_t arg3,
|
|
int32_t arg4, int32_t arg5, int32_t arg6, int32_t arg7,
|
|
int32_t arg8, int32_t arg9, int32_t arg10,
|
|
int32_t arg11, int32_t arg12, int32_t arg13,
|
|
int32_t arg14, int32_t arg15, int32_t arg16,
|
|
int32_t arg17, int32_t arg18, int32_t arg19) {
|
|
CHECK(SIGNATURE_ONLY_INT_20(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithSignatureOnlyInt20, SIGNATURE_ONLY_INT_20,
|
|
func_only_int_20)
|
|
|
|
#define MIXED_SIGNATURE_SIMPLE_FLOAT(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(float, 1, 1.5) \
|
|
V##_END(int32_t, 2, 2)
|
|
|
|
int64_t test_api_func_simple_float(int32_t arg0, float arg1, int32_t arg2) {
|
|
CHECK(MIXED_SIGNATURE_SIMPLE_FLOAT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureSimpleFloat,
|
|
MIXED_SIGNATURE_SIMPLE_FLOAT, test_api_func_simple_float)
|
|
|
|
#define MIXED_SIGNATURE_FLOAT(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(float, 1, 1.5) \
|
|
V(int32_t, 2, 2) \
|
|
V(float, 3, 3.5) \
|
|
V(int32_t, 4, 4) \
|
|
V(float, 5, 5.5) \
|
|
V(int32_t, 6, 6) \
|
|
V(float, 7, 7.5) \
|
|
V(int32_t, 8, 8) \
|
|
V(float, 9, 9.5) \
|
|
V##_END(int32_t, 10, 10)
|
|
|
|
int64_t test_api_func_float(int32_t arg0, float arg1, int32_t arg2, float arg3,
|
|
int32_t arg4, float arg5, int32_t arg6, float arg7,
|
|
int32_t arg8, float arg9, int32_t arg10) {
|
|
CHECK(MIXED_SIGNATURE_FLOAT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureFloat, MIXED_SIGNATURE_FLOAT,
|
|
test_api_func_float)
|
|
|
|
#define MIXED_SIGNATURE_INT_FLOAT_ALT(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(float, 1, 1.5) \
|
|
V(int32_t, 2, 2) \
|
|
V(float, 3, 3.5) \
|
|
V(int32_t, 4, 4) \
|
|
V(float, 5, 5.5) \
|
|
V(int32_t, 6, 6) \
|
|
V(float, 7, 7.5) \
|
|
V(int32_t, 8, 8) \
|
|
V(float, 9, 9.5) \
|
|
V(int32_t, 10, 10) \
|
|
V(float, 11, 11.5) \
|
|
V(int32_t, 12, 12) \
|
|
V(float, 13, 13.5) \
|
|
V(int32_t, 14, 14) \
|
|
V(float, 15, 15.5) \
|
|
V(int32_t, 16, 16) \
|
|
V(float, 17, 17.5) \
|
|
V(int32_t, 18, 18) \
|
|
V##_END(float, 19, 19.5)
|
|
|
|
int64_t func_mixed_int_float_alt(int32_t arg0, float arg1, int32_t arg2,
|
|
float arg3, int32_t arg4, float arg5,
|
|
int32_t arg6, float arg7, int32_t arg8,
|
|
float arg9, int32_t arg10, float arg11,
|
|
int32_t arg12, float arg13, int32_t arg14,
|
|
float arg15, int32_t arg16, float arg17,
|
|
int32_t arg18, float arg19) {
|
|
CHECK(MIXED_SIGNATURE_INT_FLOAT_ALT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureIntFloatAlt,
|
|
MIXED_SIGNATURE_INT_FLOAT_ALT, func_mixed_int_float_alt)
|
|
|
|
#define SIGNATURE_ONLY_FLOAT_20(V) \
|
|
V(float, 0, 0.5) \
|
|
V(float, 1, 1.5) \
|
|
V(float, 2, 2.5) \
|
|
V(float, 3, 3.5) \
|
|
V(float, 4, 4.5) \
|
|
V(float, 5, 5.5) \
|
|
V(float, 6, 6.5) \
|
|
V(float, 7, 7.5) \
|
|
V(float, 8, 8.5) \
|
|
V(float, 9, 9.5) \
|
|
V(float, 10, 10.5) \
|
|
V(float, 11, 11.5) \
|
|
V(float, 12, 12.5) \
|
|
V(float, 13, 13.5) \
|
|
V(float, 14, 14.5) \
|
|
V(float, 15, 15.5) \
|
|
V(float, 16, 16.5) \
|
|
V(float, 17, 17.5) \
|
|
V(float, 18, 18.5) \
|
|
V##_END(float, 19, 19.5)
|
|
|
|
int64_t func_only_float_20(float arg0, float arg1, float arg2, float arg3,
|
|
float arg4, float arg5, float arg6, float arg7,
|
|
float arg8, float arg9, float arg10, float arg11,
|
|
float arg12, float arg13, float arg14, float arg15,
|
|
float arg16, float arg17, float arg18, float arg19) {
|
|
CHECK(SIGNATURE_ONLY_FLOAT_20(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithSignatureOnlyFloat20, SIGNATURE_ONLY_FLOAT_20,
|
|
func_only_float_20)
|
|
|
|
#define MIXED_SIGNATURE_FLOAT_INT(V) \
|
|
V(float, 0, 0.5) \
|
|
V(float, 1, 1.5) \
|
|
V(float, 2, 2.5) \
|
|
V(float, 3, 3.5) \
|
|
V(float, 4, 4.5) \
|
|
V(float, 5, 5.5) \
|
|
V(float, 6, 6.5) \
|
|
V(float, 7, 7.5) \
|
|
V(float, 8, 8.5) \
|
|
V(float, 9, 9.5) \
|
|
V(int32_t, 10, 10) \
|
|
V(int32_t, 11, 11) \
|
|
V(int32_t, 12, 12) \
|
|
V(int32_t, 13, 13) \
|
|
V(int32_t, 14, 14) \
|
|
V(int32_t, 15, 15) \
|
|
V(int32_t, 16, 16) \
|
|
V(int32_t, 17, 17) \
|
|
V(int32_t, 18, 18) \
|
|
V##_END(int32_t, 19, 19)
|
|
|
|
int64_t func_mixed_float_int(float arg0, float arg1, float arg2, float arg3,
|
|
float arg4, float arg5, float arg6, float arg7,
|
|
float arg8, float arg9, int32_t arg10,
|
|
int32_t arg11, int32_t arg12, int32_t arg13,
|
|
int32_t arg14, int32_t arg15, int32_t arg16,
|
|
int32_t arg17, int32_t arg18, int32_t arg19) {
|
|
CHECK(MIXED_SIGNATURE_FLOAT_INT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureFloatInt, MIXED_SIGNATURE_FLOAT_INT,
|
|
func_mixed_float_int)
|
|
|
|
#define MIXED_SIGNATURE_INT_FLOAT(V) \
|
|
V(int32_t, 0, 0) \
|
|
V(int32_t, 1, 1) \
|
|
V(int32_t, 2, 2) \
|
|
V(int32_t, 3, 3) \
|
|
V(int32_t, 4, 4) \
|
|
V(int32_t, 5, 5) \
|
|
V(int32_t, 6, 6) \
|
|
V(int32_t, 7, 7) \
|
|
V(int32_t, 8, 8) \
|
|
V(int32_t, 9, 9) \
|
|
V(float, 10, 10.5) \
|
|
V(float, 11, 11.5) \
|
|
V(float, 12, 12.5) \
|
|
V(float, 13, 13.5) \
|
|
V(float, 14, 14.5) \
|
|
V(float, 15, 15.5) \
|
|
V(float, 16, 16.5) \
|
|
V(float, 17, 17.5) \
|
|
V(float, 18, 18.5) \
|
|
V##_END(float, 19, 19.5)
|
|
|
|
int64_t func_mixed_int_float(int32_t arg0, int32_t arg1, int32_t arg2,
|
|
int32_t arg3, int32_t arg4, int32_t arg5,
|
|
int32_t arg6, int32_t arg7, int32_t arg8,
|
|
int32_t arg9, float arg10, float arg11,
|
|
float arg12, float arg13, float arg14, float arg15,
|
|
float arg16, float arg17, float arg18,
|
|
float arg19) {
|
|
CHECK(MIXED_SIGNATURE_INT_FLOAT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureIntFloat, MIXED_SIGNATURE_INT_FLOAT,
|
|
func_mixed_int_float)
|
|
|
|
#define MIXED_SIGNATURE_FLOAT_DOUBLE(V) \
|
|
V(float, 0, 0.5) \
|
|
V(float, 1, 1.5) \
|
|
V(float, 2, 2.5) \
|
|
V(float, 3, 3.5) \
|
|
V(float, 4, 4.5) \
|
|
V(float, 5, 5.5) \
|
|
V(float, 6, 6.5) \
|
|
V(float, 7, 7.5) \
|
|
V(float, 8, 8.5) \
|
|
V(float, 9, 9.5) \
|
|
V(double, 10, 10.7) \
|
|
V(double, 11, 11.7) \
|
|
V(double, 12, 12.7) \
|
|
V(double, 13, 13.7) \
|
|
V(double, 14, 14.7) \
|
|
V(double, 15, 15.7) \
|
|
V(double, 16, 16.7) \
|
|
V(double, 17, 17.7) \
|
|
V(double, 18, 18.7) \
|
|
V##_END(double, 19, 19.7)
|
|
|
|
int64_t func_mixed_float_double(float arg0, float arg1, float arg2, float arg3,
|
|
float arg4, float arg5, float arg6, float arg7,
|
|
float arg8, float arg9, double arg10,
|
|
double arg11, double arg12, double arg13,
|
|
double arg14, double arg15, double arg16,
|
|
double arg17, double arg18, double arg19) {
|
|
CHECK(MIXED_SIGNATURE_FLOAT_DOUBLE(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureFloatDouble,
|
|
MIXED_SIGNATURE_FLOAT_DOUBLE, func_mixed_float_double)
|
|
|
|
#define MIXED_SIGNATURE_DOUBLE_FLOAT(V) \
|
|
V(double, 0, 0.7) \
|
|
V(double, 1, 1.7) \
|
|
V(double, 2, 2.7) \
|
|
V(double, 3, 3.7) \
|
|
V(double, 4, 4.7) \
|
|
V(double, 5, 5.7) \
|
|
V(double, 6, 6.7) \
|
|
V(double, 7, 7.7) \
|
|
V(double, 8, 8.7) \
|
|
V(double, 9, 9.7) \
|
|
V(float, 10, 10.5) \
|
|
V(float, 11, 11.5) \
|
|
V(float, 12, 12.5) \
|
|
V(float, 13, 13.5) \
|
|
V(float, 14, 14.5) \
|
|
V(float, 15, 15.5) \
|
|
V(float, 16, 16.5) \
|
|
V(float, 17, 17.5) \
|
|
V(float, 18, 18.5) \
|
|
V##_END(float, 19, 19.5)
|
|
|
|
int64_t func_mixed_double_float(double arg0, double arg1, double arg2,
|
|
double arg3, double arg4, double arg5,
|
|
double arg6, double arg7, double arg8,
|
|
double arg9, float arg10, float arg11,
|
|
float arg12, float arg13, float arg14,
|
|
float arg15, float arg16, float arg17,
|
|
float arg18, float arg19) {
|
|
CHECK(MIXED_SIGNATURE_DOUBLE_FLOAT(COMPARE_ARG_I));
|
|
return 42;
|
|
}
|
|
|
|
SIGNATURE_TEST(RunCallWithMixedSignatureDoubleFloat,
|
|
MIXED_SIGNATURE_DOUBLE_FLOAT, func_mixed_double_float)
|
|
|
|
#endif // V8_ENABLE_FP_PARAMS_IN_C_LINKAGE
|
|
|
|
} // namespace compiler
|
|
} // namespace internal
|
|
} // namespace v8
|