0818d13807
- Fixes a problem when constructing Wasm CallDescriptors, where the allocation tries to treat parameters and returns as if they are in the same frame. This doesn't work when slots may be aligned in their frame. Instead, allocate parameters and returns separately and offset return slots by the number of parameter slots. - Adds argument slot padding in the CallDescriptor lowering case, to prepare for when 32 bit targets align stack frames and require padding. - Adds a regression test. Bug: chromium:1174500 Change-Id: I60d96a94b171a0d27ff61cbab35623976b0c6da8 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2683024 Commit-Queue: Bill Budge <bbudge@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#72588}
112 lines
4.4 KiB
C++
112 lines
4.4 KiB
C++
// Copyright 2018 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/compiler/wasm-compiler.h"
|
|
|
|
#include "src/codegen/machine-type.h"
|
|
#include "src/codegen/signature.h"
|
|
#include "src/compiler/linkage.h"
|
|
#include "src/wasm/value-type.h"
|
|
#include "src/wasm/wasm-linkage.h"
|
|
#include "test/unittests/test-utils.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
namespace wasm {
|
|
|
|
class WasmCallDescriptorTest : public TestWithZone {};
|
|
|
|
TEST_F(WasmCallDescriptorTest, TestExternRefIsGrouped) {
|
|
constexpr size_t kMaxCount = 30;
|
|
ValueType params[kMaxCount];
|
|
|
|
for (size_t i = 0; i < kMaxCount; i += 2) {
|
|
params[i] = kWasmExternRef;
|
|
EXPECT_TRUE(i + 1 < kMaxCount);
|
|
params[i + 1] = kWasmI32;
|
|
}
|
|
|
|
for (size_t count = 1; count <= kMaxCount; ++count) {
|
|
FunctionSig sig(/*return_count=*/0, count, params);
|
|
compiler::CallDescriptor* desc =
|
|
compiler::GetWasmCallDescriptor(zone(), &sig);
|
|
|
|
// The WasmInstance is the implicit first parameter.
|
|
EXPECT_EQ(count + 1, desc->ParameterCount());
|
|
|
|
bool has_untagged_stack_param = false;
|
|
bool has_tagged_register_param = false;
|
|
int max_tagged_stack_location = std::numeric_limits<int>::min();
|
|
int min_untagged_stack_location = std::numeric_limits<int>::max();
|
|
for (size_t i = 1; i < desc->ParameterCount(); ++i) {
|
|
// InputLocation i + 1, because target is the first input.
|
|
compiler::LinkageLocation location = desc->GetInputLocation(i + 1);
|
|
if (desc->GetParameterType(i).IsTagged()) {
|
|
if (location.IsRegister()) {
|
|
has_tagged_register_param = true;
|
|
} else {
|
|
EXPECT_TRUE(location.IsCallerFrameSlot());
|
|
max_tagged_stack_location =
|
|
std::max(max_tagged_stack_location, location.AsCallerFrameSlot());
|
|
}
|
|
} else { // !isTagged()
|
|
if (location.IsCallerFrameSlot()) {
|
|
has_untagged_stack_param = true;
|
|
min_untagged_stack_location = std::min(min_untagged_stack_location,
|
|
location.AsCallerFrameSlot());
|
|
} else {
|
|
EXPECT_TRUE(location.IsRegister());
|
|
}
|
|
}
|
|
}
|
|
// There should never be a tagged parameter in a register and an untagged
|
|
// parameter on the stack at the same time.
|
|
EXPECT_EQ(false, has_tagged_register_param && has_untagged_stack_param);
|
|
EXPECT_TRUE(max_tagged_stack_location < min_untagged_stack_location);
|
|
}
|
|
}
|
|
|
|
TEST_F(WasmCallDescriptorTest, Regress_1174500) {
|
|
// Our test signature should have just enough params and returns to force
|
|
// 1 param and 1 return to be allocated as stack slots. Use FP registers to
|
|
// avoid interference with implicit parameters, like the Wasm Instance.
|
|
constexpr int kParamRegisters = arraysize(kFpParamRegisters);
|
|
constexpr int kParams = kParamRegisters + 1;
|
|
constexpr int kReturnRegisters = arraysize(kFpReturnRegisters);
|
|
constexpr int kReturns = kReturnRegisters + 1;
|
|
ValueType types[kReturns + kParams];
|
|
// One S128 return slot which shouldn't be padded unless the arguments area
|
|
// of the frame requires it.
|
|
for (int i = 0; i < kReturnRegisters; ++i) types[i] = kWasmF32;
|
|
types[kReturnRegisters] = kWasmS128;
|
|
// One F32 parameter slot to misalign the parameter area.
|
|
for (int i = 0; i < kParamRegisters; ++i) types[kReturns + i] = kWasmF32;
|
|
types[kReturns + kParamRegisters] = kWasmF32;
|
|
|
|
FunctionSig sig(kReturns, kParams, types);
|
|
compiler::CallDescriptor* desc =
|
|
compiler::GetWasmCallDescriptor(zone(), &sig);
|
|
|
|
// Get the location of our stack parameter slot. Skip the implicit Wasm
|
|
// instance parameter.
|
|
compiler::LinkageLocation last_param = desc->GetInputLocation(kParams + 1);
|
|
EXPECT_TRUE(last_param.IsCallerFrameSlot());
|
|
EXPECT_EQ(MachineType::Float32(), last_param.GetType());
|
|
EXPECT_EQ(-1, last_param.GetLocation());
|
|
|
|
// The stack return slot should be right above our last parameter, and any
|
|
// argument padding slots. The return slot itself should not be padded.
|
|
const int padding = kPadArguments ? 1 : 0;
|
|
const int first_return_slot = -1 - (padding + 1);
|
|
compiler::LinkageLocation return_location =
|
|
desc->GetReturnLocation(kReturns - 1);
|
|
EXPECT_TRUE(return_location.IsCallerFrameSlot());
|
|
EXPECT_EQ(MachineType::Simd128(), return_location.GetType());
|
|
EXPECT_EQ(first_return_slot, return_location.GetLocation());
|
|
}
|
|
|
|
} // namespace wasm
|
|
} // namespace internal
|
|
} // namespace v8
|