Skip to content

V
V8
Commit 95bec7e7 authored by oth's avatar oth Committed by Commit bot
Browse files
Options

[interpreter] Reduce move operations for wide register support. 

Introduces the concept of transfer direction to register operands. This
enables the register translator to emit exactly the moves that a
bytecode having it's register operands translated needs.

BUG=v8:4280,v8:4675
LOG=N

Review URL: https://codereview.chromium.org/1633153002

Cr-Commit-Position: refs/heads/master@{#33544}
parent f22a5663
Expand all Show whitespace changes
Inline Side-by-side
Showing with 510 additions and 456 deletions
src/compiler/interpreter-assembler.cc
View file @ 95bec7e7
...@@ -305,31 +305,18 @@ Node* InterpreterAssembler::BytecodeOperandIdx(int operand_index) { ...@@ -305,31 +305,18 @@ Node* InterpreterAssembler::BytecodeOperandIdx(int operand_index) {
Node* InterpreterAssembler::BytecodeOperandReg(int operand_index) { Node* InterpreterAssembler::BytecodeOperandReg(int operand_index) {
switch (interpreter::Bytecodes::GetOperandType(bytecode_, operand_index)) { interpreter::OperandType operand_type =
case interpreter::OperandType::kMaybeReg8: interpreter::Bytecodes::GetOperandType(bytecode_, operand_index);
case interpreter::OperandType::kReg8: if (interpreter::Bytecodes::IsRegisterOperandType(operand_type)) {
case interpreter::OperandType::kRegPair8: interpreter::OperandSize operand_size =
case interpreter::OperandType::kRegTriple8: interpreter::Bytecodes::SizeOfOperand(operand_type);
DCHECK_EQ( if (operand_size == interpreter::OperandSize::kByte) {
interpreter::OperandSize::kByte,
interpreter::Bytecodes::GetOperandSize(bytecode_, operand_index));
return BytecodeOperandSignExtended(operand_index); return BytecodeOperandSignExtended(operand_index);
case interpreter::OperandType::kMaybeReg16: } else if (operand_size == interpreter::OperandSize::kShort) {
case interpreter::OperandType::kReg16:
case interpreter::OperandType::kRegPair16:
case interpreter::OperandType::kRegTriple16:
DCHECK_EQ(
interpreter::OperandSize::kShort,
interpreter::Bytecodes::GetOperandSize(bytecode_, operand_index));
return BytecodeOperandShortSignExtended(operand_index); return BytecodeOperandShortSignExtended(operand_index);
case interpreter::OperandType::kNone:
case interpreter::OperandType::kIdx8:
case interpreter::OperandType::kIdx16:
case interpreter::OperandType::kImm8:
case interpreter::OperandType::kRegCount8:
case interpreter::OperandType::kRegCount16:
UNREACHABLE();
} }
}
UNREACHABLE();
return nullptr; return nullptr;
} }
......
src/interpreter/bytecode-array-builder.cc
View file @ 95bec7e7
...@@ -401,25 +401,6 @@ void BytecodeArrayBuilder::MoveRegisterUntranslated(Register from, ...@@ -401,25 +401,6 @@ void BytecodeArrayBuilder::MoveRegisterUntranslated(Register from,
Output(Bytecode::kMovWide, from.ToRawOperand(), to.ToRawOperand()); Output(Bytecode::kMovWide, from.ToRawOperand(), to.ToRawOperand());
} }
bool BytecodeArrayBuilder::RegisterOperandIsMovable(Bytecode bytecode,
int operand_index) {
// By design, we only support moving individual registers. There
// should be wide variants of such bytecodes instead to avoid the
// need for a large translation window.
OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
if (operand_type != OperandType::kReg8 &&
operand_type != OperandType::kReg16) {
return false;
} else if (operand_index + 1 == Bytecodes::NumberOfOperands(bytecode)) {
return true;
} else {
OperandType next_operand_type =
Bytecodes::GetOperandType(bytecode, operand_index + 1);
return (next_operand_type != OperandType::kRegCount8 &&
next_operand_type != OperandType::kRegCount16);
}
}
BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal( BytecodeArrayBuilder& BytecodeArrayBuilder::LoadGlobal(
const Handle<String> name, int feedback_slot, LanguageMode language_mode, const Handle<String> name, int feedback_slot, LanguageMode language_mode,
TypeofMode typeof_mode) { TypeofMode typeof_mode) {
...@@ -1413,8 +1394,11 @@ bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index, ...@@ -1413,8 +1394,11 @@ bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index,
} }
// Fall-through to kReg8 case. // Fall-through to kReg8 case.
case OperandType::kReg8: case OperandType::kReg8:
case OperandType::kRegOut8:
return RegisterIsValid(Register::FromRawOperand(operand_value), return RegisterIsValid(Register::FromRawOperand(operand_value),
operand_type); operand_type);
case OperandType::kRegOutPair8:
case OperandType::kRegOutPair16:
case OperandType::kRegPair8: case OperandType::kRegPair8:
case OperandType::kRegPair16: { case OperandType::kRegPair16: {
Register reg0 = Register::FromRawOperand(operand_value); Register reg0 = Register::FromRawOperand(operand_value);
...@@ -1422,8 +1406,8 @@ bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index, ...@@ -1422,8 +1406,8 @@ bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index,
return RegisterIsValid(reg0, operand_type) && return RegisterIsValid(reg0, operand_type) &&
RegisterIsValid(reg1, operand_type); RegisterIsValid(reg1, operand_type);
} }
case OperandType::kRegTriple8: case OperandType::kRegOutTriple8:
case OperandType::kRegTriple16: { case OperandType::kRegOutTriple16: {
Register reg0 = Register::FromRawOperand(operand_value); Register reg0 = Register::FromRawOperand(operand_value);
Register reg1 = Register(reg0.index() + 1); Register reg1 = Register(reg0.index() + 1);
Register reg2 = Register(reg0.index() + 2); Register reg2 = Register(reg0.index() + 2);
...@@ -1436,7 +1420,8 @@ bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index, ...@@ -1436,7 +1420,8 @@ bool BytecodeArrayBuilder::OperandIsValid(Bytecode bytecode, int operand_index,
return true; return true;
} }
// Fall-through to kReg16 case. // Fall-through to kReg16 case.
case OperandType::kReg16: { case OperandType::kReg16:
case OperandType::kRegOut16: {
Register reg = Register::FromRawOperand(operand_value); Register reg = Register::FromRawOperand(operand_value);
return RegisterIsValid(reg, operand_type); return RegisterIsValid(reg, operand_type);
} }
......
src/interpreter/bytecode-array-builder.h
View file @ 95bec7e7
...@@ -281,9 +281,8 @@ class BytecodeArrayBuilder final : private RegisterMover { ...@@ -281,9 +281,8 @@ class BytecodeArrayBuilder final : private RegisterMover {
static bool FitsInReg16Operand(Register value); static bool FitsInReg16Operand(Register value);
static bool FitsInReg16OperandUntranslated(Register value); static bool FitsInReg16OperandUntranslated(Register value);
// RegisterMover interface methods. // RegisterMover interface.
void MoveRegisterUntranslated(Register from, Register to) override; void MoveRegisterUntranslated(Register from, Register to) override;
bool RegisterOperandIsMovable(Bytecode bytecode, int operand_index) override;
static Bytecode GetJumpWithConstantOperand(Bytecode jump_smi8_operand); static Bytecode GetJumpWithConstantOperand(Bytecode jump_smi8_operand);
static Bytecode GetJumpWithConstantWideOperand(Bytecode jump_smi8_operand); static Bytecode GetJumpWithConstantWideOperand(Bytecode jump_smi8_operand);
......
src/interpreter/bytecode-array-iterator.cc
View file @ 95bec7e7
...@@ -87,11 +87,7 @@ int BytecodeArrayIterator::GetIndexOperand(int operand_index) const { ...@@ -87,11 +87,7 @@ int BytecodeArrayIterator::GetIndexOperand(int operand_index) const {
Register BytecodeArrayIterator::GetRegisterOperand(int operand_index) const { Register BytecodeArrayIterator::GetRegisterOperand(int operand_index) const {
OperandType operand_type = OperandType operand_type =
Bytecodes::GetOperandType(current_bytecode(), operand_index); Bytecodes::GetOperandType(current_bytecode(), operand_index);
DCHECK(operand_type == OperandType::kReg8 || DCHECK(Bytecodes::IsRegisterOperandType(operand_type));
operand_type == OperandType::kRegPair8 ||
operand_type == OperandType::kRegTriple8 ||
operand_type == OperandType::kMaybeReg8 ||
operand_type == OperandType::kReg16);
uint32_t operand = GetRawOperand(operand_index, operand_type); uint32_t operand = GetRawOperand(operand_index, operand_type);
switch (Bytecodes::GetOperandSize(current_bytecode(), operand_index)) { switch (Bytecodes::GetOperandSize(current_bytecode(), operand_index)) {
case OperandSize::kByte: case OperandSize::kByte:
......
src/interpreter/bytecodes.cc
View file @ 95bec7e7
...@@ -262,6 +262,58 @@ bool Bytecodes::IsJumpOrReturn(Bytecode bytecode) { ...@@ -262,6 +262,58 @@ bool Bytecodes::IsJumpOrReturn(Bytecode bytecode) {
return bytecode == Bytecode::kReturn || IsJump(bytecode); return bytecode == Bytecode::kReturn || IsJump(bytecode);
} }
// static
bool Bytecodes::IsRegisterOperandType(OperandType operand_type) {
switch (operand_type) {
#define CASE(Name, _) \
case OperandType::k##Name: \
return true;
REGISTER_OPERAND_TYPE_LIST(CASE)
#undef CASE
#define CASE(Name, _) \
case OperandType::k##Name: \
break;
NON_REGISTER_OPERAND_TYPE_LIST(CASE)
#undef CASE
}
return false;
}
// static
bool Bytecodes::IsRegisterInputOperandType(OperandType operand_type) {
switch (operand_type) {
#define CASE(Name, _) \
case OperandType::k##Name: \
return true;
REGISTER_INPUT_OPERAND_TYPE_LIST(CASE)
#undef CASE
#define CASE(Name, _) \
case OperandType::k##Name: \
break;
NON_REGISTER_OPERAND_TYPE_LIST(CASE)
REGISTER_OUTPUT_OPERAND_TYPE_LIST(CASE)
#undef CASE
}
return false;
}
// static
bool Bytecodes::IsRegisterOutputOperandType(OperandType operand_type) {
switch (operand_type) {
#define CASE(Name, _) \
case OperandType::k##Name: \
return true;
REGISTER_OUTPUT_OPERAND_TYPE_LIST(CASE)
#undef CASE
#define CASE(Name, _) \
case OperandType::k##Name: \
break;
NON_REGISTER_OPERAND_TYPE_LIST(CASE)
REGISTER_INPUT_OPERAND_TYPE_LIST(CASE)
#undef CASE
}
return false;
}
namespace { namespace {
static Register DecodeRegister(const uint8_t* operand_start, static Register DecodeRegister(const uint8_t* operand_start,
...@@ -300,6 +352,7 @@ std::ostream& Bytecodes::Decode(std::ostream& os, const uint8_t* bytecode_start, ...@@ -300,6 +352,7 @@ std::ostream& Bytecodes::Decode(std::ostream& os, const uint8_t* bytecode_start,
os << bytecode << " "; os << bytecode << " ";
int number_of_operands = NumberOfOperands(bytecode); int number_of_operands = NumberOfOperands(bytecode);
int range = 0;
for (int i = 0; i < number_of_operands; i++) { for (int i = 0; i < number_of_operands; i++) {
OperandType op_type = GetOperandType(bytecode, i); OperandType op_type = GetOperandType(bytecode, i);
const uint8_t* operand_start = const uint8_t* operand_start =
...@@ -323,7 +376,9 @@ std::ostream& Bytecodes::Decode(std::ostream& os, const uint8_t* bytecode_start, ...@@ -323,7 +376,9 @@ std::ostream& Bytecodes::Decode(std::ostream& os, const uint8_t* bytecode_start,
case interpreter::OperandType::kMaybeReg8: case interpreter::OperandType::kMaybeReg8:
case interpreter::OperandType::kMaybeReg16: case interpreter::OperandType::kMaybeReg16:
case interpreter::OperandType::kReg8: case interpreter::OperandType::kReg8:
case interpreter::OperandType::kReg16: { case interpreter::OperandType::kReg16:
case interpreter::OperandType::kRegOut8:
case interpreter::OperandType::kRegOut16: {
Register reg = DecodeRegister(operand_start, op_type); Register reg = DecodeRegister(operand_start, op_type);
if (reg.is_current_context()) { if (reg.is_current_context()) {
os << "<context>"; os << "<context>";
...@@ -343,12 +398,15 @@ std::ostream& Bytecodes::Decode(std::ostream& os, const uint8_t* bytecode_start, ...@@ -343,12 +398,15 @@ std::ostream& Bytecodes::Decode(std::ostream& os, const uint8_t* bytecode_start,
} }
break; break;
} }
case interpreter::OperandType::kRegOutTriple8:
case interpreter::OperandType::kRegOutTriple16:
range += 1;
case interpreter::OperandType::kRegOutPair8:
case interpreter::OperandType::kRegOutPair16:
case interpreter::OperandType::kRegPair8: case interpreter::OperandType::kRegPair8:
case interpreter::OperandType::kRegTriple8: case interpreter::OperandType::kRegPair16: {
case interpreter::OperandType::kRegPair16: range += 1;
case interpreter::OperandType::kRegTriple16: {
Register reg = DecodeRegister(operand_start, op_type); Register reg = DecodeRegister(operand_start, op_type);
int range = op_type == interpreter::OperandType::kRegPair8 ? 1 : 2;
if (reg.is_parameter()) { if (reg.is_parameter()) {
int parameter_index = reg.ToParameterIndex(parameter_count); int parameter_index = reg.ToParameterIndex(parameter_count);
DCHECK_GT(parameter_index, 0); DCHECK_GT(parameter_index, 0);
...@@ -456,7 +514,6 @@ bool Register::is_new_target() const { ...@@ -456,7 +514,6 @@ bool Register::is_new_target() const {
return index() == kNewTargetRegisterIndex; return index() == kNewTargetRegisterIndex;
} }
int Register::MaxParameterIndex() { return kMaxParameterIndex; } int Register::MaxParameterIndex() { return kMaxParameterIndex; }
int Register::MaxRegisterIndex() { return kMaxRegisterIndex; } int Register::MaxRegisterIndex() { return kMaxRegisterIndex; }
......
src/interpreter/bytecodes.h
View file @ 95bec7e7
...@@ -18,17 +18,25 @@ namespace interpreter { ...@@ -18,17 +18,25 @@ namespace interpreter {
#define INVALID_OPERAND_TYPE_LIST(V) \ #define INVALID_OPERAND_TYPE_LIST(V) \
V(None, OperandSize::kNone) V(None, OperandSize::kNone)
#define REGISTER_OPERAND_TYPE_LIST(V) \ #define REGISTER_INPUT_OPERAND_TYPE_LIST(V) \
/* Byte operands. */ \ /* Byte operands. */ \
V(MaybeReg8, OperandSize::kByte) \ V(MaybeReg8, OperandSize::kByte) \
V(Reg8, OperandSize::kByte) \ V(Reg8, OperandSize::kByte) \
V(RegPair8, OperandSize::kByte) \ V(RegPair8, OperandSize::kByte) \
V(RegTriple8, OperandSize::kByte) \
/* Short operands. */ \ /* Short operands. */ \
V(MaybeReg16, OperandSize::kShort) \ V(MaybeReg16, OperandSize::kShort) \
V(Reg16, OperandSize::kShort) \ V(Reg16, OperandSize::kShort) \
V(RegPair16, OperandSize::kShort) \ V(RegPair16, OperandSize::kShort)
V(RegTriple16, OperandSize::kShort)
#define REGISTER_OUTPUT_OPERAND_TYPE_LIST(V) \
/* Byte operands. */ \
V(RegOut8, OperandSize::kByte) \
V(RegOutPair8, OperandSize::kByte) \
V(RegOutTriple8, OperandSize::kByte) \
/* Short operands. */ \
V(RegOut16, OperandSize::kShort) \
V(RegOutPair16, OperandSize::kShort) \
V(RegOutTriple16, OperandSize::kShort)
#define SCALAR_OPERAND_TYPE_LIST(V) \ #define SCALAR_OPERAND_TYPE_LIST(V) \
/* Byte operands. */ \ /* Byte operands. */ \
...@@ -39,12 +47,19 @@ namespace interpreter { ...@@ -39,12 +47,19 @@ namespace interpreter {
V(Idx16, OperandSize::kShort) \ V(Idx16, OperandSize::kShort) \
V(RegCount16, OperandSize::kShort) V(RegCount16, OperandSize::kShort)
// The list of operand types used by bytecodes. #define REGISTER_OPERAND_TYPE_LIST(V) \
#define OPERAND_TYPE_LIST(V) \ REGISTER_INPUT_OPERAND_TYPE_LIST(V) \
REGISTER_OUTPUT_OPERAND_TYPE_LIST(V)
#define NON_REGISTER_OPERAND_TYPE_LIST(V) \
INVALID_OPERAND_TYPE_LIST(V) \ INVALID_OPERAND_TYPE_LIST(V) \
REGISTER_OPERAND_TYPE_LIST(V) \
SCALAR_OPERAND_TYPE_LIST(V) SCALAR_OPERAND_TYPE_LIST(V)
// The list of operand types used by bytecodes.
#define OPERAND_TYPE_LIST(V) \
NON_REGISTER_OPERAND_TYPE_LIST(V) \
REGISTER_OPERAND_TYPE_LIST(V)
// The list of bytecodes which are interpreted by the interpreter. // The list of bytecodes which are interpreted by the interpreter.
#define BYTECODE_LIST(V) \ #define BYTECODE_LIST(V) \
\ \
...@@ -93,11 +108,11 @@ namespace interpreter { ...@@ -93,11 +108,11 @@ namespace interpreter {
\ \
/* Register-accumulator transfers */ \ /* Register-accumulator transfers */ \
V(Ldar, OperandType::kReg8) \ V(Ldar, OperandType::kReg8) \
V(Star, OperandType::kReg8) \ V(Star, OperandType::kRegOut8) \
\ \
/* Register-register transfers */ \ /* Register-register transfers */ \
V(Mov, OperandType::kReg8, OperandType::kReg8) \ V(Mov, OperandType::kReg8, OperandType::kRegOut8) \
V(MovWide, OperandType::kReg16, OperandType::kReg16) \ V(MovWide, OperandType::kReg16, OperandType::kRegOut16) \
\ \
/* LoadIC operations */ \ /* LoadIC operations */ \
V(LoadICSloppy, OperandType::kReg8, OperandType::kIdx8, OperandType::kIdx8) \ V(LoadICSloppy, OperandType::kReg8, OperandType::kIdx8, OperandType::kIdx8) \
...@@ -159,9 +174,9 @@ namespace interpreter { ...@@ -159,9 +174,9 @@ namespace interpreter {
V(CallRuntimeWide, OperandType::kIdx16, OperandType::kMaybeReg16, \ V(CallRuntimeWide, OperandType::kIdx16, OperandType::kMaybeReg16, \
OperandType::kRegCount8) \ OperandType::kRegCount8) \
V(CallRuntimeForPair, OperandType::kIdx16, OperandType::kMaybeReg8, \ V(CallRuntimeForPair, OperandType::kIdx16, OperandType::kMaybeReg8, \
OperandType::kRegCount8, OperandType::kRegPair8) \ OperandType::kRegCount8, OperandType::kRegOutPair8) \
V(CallRuntimeForPairWide, OperandType::kIdx16, OperandType::kMaybeReg16, \ V(CallRuntimeForPairWide, OperandType::kIdx16, OperandType::kMaybeReg16, \
OperandType::kRegCount8, OperandType::kRegPair16) \ OperandType::kRegCount8, OperandType::kRegOutPair16) \
V(CallJSRuntime, OperandType::kIdx16, OperandType::kReg8, \ V(CallJSRuntime, OperandType::kIdx16, OperandType::kReg8, \
OperandType::kRegCount8) \ OperandType::kRegCount8) \
V(CallJSRuntimeWide, OperandType::kIdx16, OperandType::kReg16, \ V(CallJSRuntimeWide, OperandType::kIdx16, OperandType::kReg16, \
...@@ -235,8 +250,8 @@ namespace interpreter { ...@@ -235,8 +250,8 @@ namespace interpreter {
V(JumpIfUndefinedConstantWide, OperandType::kIdx16) \ V(JumpIfUndefinedConstantWide, OperandType::kIdx16) \
\ \
/* Complex flow control For..in */ \ /* Complex flow control For..in */ \
V(ForInPrepare, OperandType::kRegTriple8) \ V(ForInPrepare, OperandType::kRegOutTriple8) \
V(ForInPrepareWide, OperandType::kRegTriple16) \ V(ForInPrepareWide, OperandType::kRegOutTriple16) \
V(ForInDone, OperandType::kReg8, OperandType::kReg8) \ V(ForInDone, OperandType::kReg8, OperandType::kReg8) \
V(ForInNext, OperandType::kReg8, OperandType::kReg8, OperandType::kRegPair8) \ V(ForInNext, OperandType::kReg8, OperandType::kReg8, OperandType::kRegPair8) \
V(ForInNextWide, OperandType::kReg16, OperandType::kReg16, \ V(ForInNextWide, OperandType::kReg16, OperandType::kReg16, \
...@@ -248,7 +263,6 @@ namespace interpreter { ...@@ -248,7 +263,6 @@ namespace interpreter {
V(ReThrow, OperandType::kNone) \ V(ReThrow, OperandType::kNone) \
V(Return, OperandType::kNone) V(Return, OperandType::kNone)
// Enumeration of the size classes of operand types used by bytecodes. // Enumeration of the size classes of operand types used by bytecodes.
enum class OperandSize : uint8_t { enum class OperandSize : uint8_t {
kNone = 0, kNone = 0,
...@@ -382,10 +396,10 @@ class Bytecodes { ...@@ -382,10 +396,10 @@ class Bytecodes {
// Returns the number of register operands expected by |bytecode|. // Returns the number of register operands expected by |bytecode|.
static int NumberOfRegisterOperands(Bytecode bytecode); static int NumberOfRegisterOperands(Bytecode bytecode);
// Return the i-th operand of |bytecode|. // Returns the i-th operand of |bytecode|.
static OperandType GetOperandType(Bytecode bytecode, int i); static OperandType GetOperandType(Bytecode bytecode, int i);
// Return the size of the i-th operand of |bytecode|. // Returns the size of the i-th operand of |bytecode|.
static OperandSize GetOperandSize(Bytecode bytecode, int i); static OperandSize GetOperandSize(Bytecode bytecode, int i);
// Returns the offset of the i-th operand of |bytecode| relative to the start // Returns the offset of the i-th operand of |bytecode| relative to the start
...@@ -430,13 +444,22 @@ class Bytecodes { ...@@ -430,13 +444,22 @@ class Bytecodes {
// constant pool entry (OperandType::kIdx16). // constant pool entry (OperandType::kIdx16).
static bool IsJumpConstantWide(Bytecode bytecode); static bool IsJumpConstantWide(Bytecode bytecode);
// Return true if the bytecode is a jump or conditional jump taking // Returns true if the bytecode is a jump or conditional jump taking
// any kind of operand. // any kind of operand.
static bool IsJump(Bytecode bytecode); static bool IsJump(Bytecode bytecode);
// Return true if the bytecode is a conditional jump, a jump, or a return. // Returns true if the bytecode is a conditional jump, a jump, or a return.
static bool IsJumpOrReturn(Bytecode bytecode); static bool IsJumpOrReturn(Bytecode bytecode);
// Returns true if |operand_type| is any type of register operand.
static bool IsRegisterOperandType(OperandType operand_type);
// Returns true if |operand_type| represents a register used as an input.
static bool IsRegisterInputOperandType(OperandType operand_type);
// Returns true if |operand_type| represents a register used as an output.
static bool IsRegisterOutputOperandType(OperandType operand_type);
// Decode a single bytecode and operands to |os|. // Decode a single bytecode and operands to |os|.
static std::ostream& Decode(std::ostream& os, const uint8_t* bytecode_start, static std::ostream& Decode(std::ostream& os, const uint8_t* bytecode_start,
int number_of_parameters); int number_of_parameters);
......
src/interpreter/register-translator.cc
View file @ 95bec7e7
...@@ -11,7 +11,10 @@ namespace internal { ...@@ -11,7 +11,10 @@ namespace internal {
namespace interpreter { namespace interpreter {
RegisterTranslator::RegisterTranslator(RegisterMover* mover) RegisterTranslator::RegisterTranslator(RegisterMover* mover)
: mover_(mover), emitting_moves_(false), window_registers_count_(0) {} : mover_(mover),
emitting_moves_(false),
window_registers_count_(0),
output_moves_count_(0) {}
void RegisterTranslator::TranslateInputRegisters(Bytecode bytecode, void RegisterTranslator::TranslateInputRegisters(Bytecode bytecode,
uint32_t* raw_operands, uint32_t* raw_operands,
...@@ -29,6 +32,7 @@ void RegisterTranslator::TranslateInputRegisters(Bytecode bytecode, ...@@ -29,6 +32,7 @@ void RegisterTranslator::TranslateInputRegisters(Bytecode bytecode,
Register out_reg = TranslateAndMove(bytecode, i, in_reg); Register out_reg = TranslateAndMove(bytecode, i, in_reg);
raw_operands[i] = out_reg.ToRawOperand(); raw_operands[i] = out_reg.ToRawOperand();
} }
window_registers_count_ = 0;
emitting_moves_ = false; emitting_moves_ = false;
} else { } else {
// When the register translator is translating registers, it will // When the register translator is translating registers, it will
...@@ -42,49 +46,70 @@ void RegisterTranslator::TranslateInputRegisters(Bytecode bytecode, ...@@ -42,49 +46,70 @@ void RegisterTranslator::TranslateInputRegisters(Bytecode bytecode,
Register RegisterTranslator::TranslateAndMove(Bytecode bytecode, Register RegisterTranslator::TranslateAndMove(Bytecode bytecode,
int operand_index, Register reg) { int operand_index, Register reg) {
if (FitsInReg8Operand(reg)) {
return reg;
}
OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index); OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
OperandSize operand_size = Bytecodes::SizeOfOperand(operand_type);
if (operand_size == OperandSize::kShort) {
CHECK(FitsInReg16Operand(reg));
return Translate(reg);
}
CHECK((operand_type == OperandType::kReg8 ||
operand_type == OperandType::kRegOut8) &&
RegisterIsMovableToWindow(bytecode, operand_index));
Register translated_reg = Translate(reg); Register translated_reg = Translate(reg);
Register addressable_reg = MakeAddressable(translated_reg, operand_type); Register window_reg(kTranslationWindowStart + window_registers_count_);
if (addressable_reg != translated_reg) { window_registers_count_ += 1;
CHECK(operand_type == OperandType::kReg8 && if (Bytecodes::IsRegisterInputOperandType(operand_type)) {
mover()->RegisterOperandIsMovable(bytecode, operand_index)); DCHECK(!Bytecodes::IsRegisterOutputOperandType(operand_type));
mover()->MoveRegisterUntranslated(translated_reg, addressable_reg); mover()->MoveRegisterUntranslated(translated_reg, window_reg);
} else if (Bytecodes::IsRegisterOutputOperandType(operand_type)) {
DCHECK_LT(output_moves_count_, kTranslationWindowLength);
output_moves_[output_moves_count_] =
std::make_pair(window_reg, translated_reg);
output_moves_count_ += 1;
} else {
UNREACHABLE();
}
return window_reg;
}
// static
bool RegisterTranslator::RegisterIsMovableToWindow(Bytecode bytecode,
int operand_index) {
// By design, we only support moving individual registers. There
// should be wide variants of such bytecodes instead to avoid the
// need for a large translation window.
OperandType operand_type = Bytecodes::GetOperandType(bytecode, operand_index);
if (operand_type != OperandType::kReg8 &&
operand_type != OperandType::kRegOut8) {
return false;
} else if (operand_index + 1 == Bytecodes::NumberOfOperands(bytecode)) {
return true;
} else {
OperandType next_operand_type =
Bytecodes::GetOperandType(bytecode, operand_index + 1);
return (next_operand_type != OperandType::kRegCount8 &&
next_operand_type != OperandType::kRegCount16);
} }
return addressable_reg;
} }
void RegisterTranslator::TranslateOutputRegisters() { void RegisterTranslator::TranslateOutputRegisters() {
if (!emitting_moves_) { if (!emitting_moves_) {
emitting_moves_ = true; emitting_moves_ = true;
while (window_registers_count_ > 0) { while (output_moves_count_ > 0) {
window_registers_count_ -= 1; output_moves_count_ -= 1;
Register source(kTranslationWindowStart + window_registers_count_); mover()->MoveRegisterUntranslated(
Register destination = window_registers_[window_registers_count_]; output_moves_[output_moves_count_].first,
mover()->MoveRegisterUntranslated(source, destination); output_moves_[output_moves_count_].second);
} }
emitting_moves_ = false; emitting_moves_ = false;
} }
} }
Register RegisterTranslator::MakeAddressable(Register reg,
OperandType reg_type) {
DCHECK(!InTranslationWindow(reg));
OperandSize reg_size = Bytecodes::SizeOfOperand(reg_type);
if (reg_size == OperandSize::kByte && !FitsInReg8Operand(reg)) {
// TODO(oth): Moves into and out from translation window could be
// decoupled if there were metadata to say whether the register
// operand was an input, output, or input-and-output for a given
// bytecode.
Register destination(kTranslationWindowStart + window_registers_count_);
window_registers_[window_registers_count_] = reg;
window_registers_count_ += 1;
DCHECK_LE(window_registers_count_, kTranslationWindowLength);
return destination;
} else {
return reg;
}
}
// static // static
Register RegisterTranslator::Translate(Register reg) { Register RegisterTranslator::Translate(Register reg) {
if (reg.index() >= kTranslationWindowStart) { if (reg.index() >= kTranslationWindowStart) {
......
src/interpreter/register-translator.h
View file @ 95bec7e7
...@@ -77,7 +77,8 @@ class RegisterTranslator final { ...@@ -77,7 +77,8 @@ class RegisterTranslator final {
kTranslationWindowLimit - kTranslationWindowLength + 1; kTranslationWindowLimit - kTranslationWindowLength + 1;
Register TranslateAndMove(Bytecode bytecode, int operand_index, Register reg); Register TranslateAndMove(Bytecode bytecode, int operand_index, Register reg);
Register MakeAddressable(Register reg, OperandType reg_type); static bool RegisterIsMovableToWindow(Bytecode bytecode, int operand_index);
static Register Translate(Register reg); static Register Translate(Register reg);
RegisterMover* mover() const { return mover_; } RegisterMover* mover() const { return mover_; }
...@@ -90,9 +91,12 @@ class RegisterTranslator final { ...@@ -90,9 +91,12 @@ class RegisterTranslator final {
// translation. // translation.
bool emitting_moves_; bool emitting_moves_;
// State for restoring registers after bytecode. // Number of window registers in use.
Register window_registers_[kTranslationWindowLength];
int window_registers_count_; int window_registers_count_;
// State for restoring register moves emitted by TranslateOutputRegisters.
std::pair<Register, Register> output_moves_[kTranslationWindowLength];
int output_moves_count_;
}; };
// Interface for RegisterTranslator helper class that will emit // Interface for RegisterTranslator helper class that will emit
...@@ -106,11 +110,6 @@ class RegisterMover { ...@@ -106,11 +110,6 @@ class RegisterMover {
// of this method must be aware that register moves with bad // of this method must be aware that register moves with bad
// register values are a security hole. // register values are a security hole.
virtual void MoveRegisterUntranslated(Register from, Register to) = 0; virtual void MoveRegisterUntranslated(Register from, Register to) = 0;
// Returns true if the register operand can be moved into the
// translation window.
virtual bool RegisterOperandIsMovable(Bytecode bytecode,
int operand_index) = 0;
}; };
} // namespace interpreter } // namespace interpreter
......
test/cctest/interpreter/test-interpreter.cc
View file @ 95bec7e7
This diff is collapsed.
test/unittests/compiler/interpreter-assembler-unittest.cc
View file @ 95bec7e7
...@@ -350,8 +350,10 @@ TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperand) { ...@@ -350,8 +350,10 @@ TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperand) {
break; break;
case interpreter::OperandType::kMaybeReg8: case interpreter::OperandType::kMaybeReg8:
case interpreter::OperandType::kReg8: case interpreter::OperandType::kReg8:
case interpreter::OperandType::kRegOut8:
case interpreter::OperandType::kRegOutPair8:
case interpreter::OperandType::kRegOutTriple8:
case interpreter::OperandType::kRegPair8: case interpreter::OperandType::kRegPair8:
case interpreter::OperandType::kRegTriple8:
EXPECT_THAT(m.BytecodeOperandReg(i), EXPECT_THAT(m.BytecodeOperandReg(i),
m.IsBytecodeOperandSignExtended(offset)); m.IsBytecodeOperandSignExtended(offset));
break; break;
...@@ -365,8 +367,10 @@ TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperand) { ...@@ -365,8 +367,10 @@ TARGET_TEST_F(InterpreterAssemblerTest, BytecodeOperand) {
break; break;
case interpreter::OperandType::kMaybeReg16: case interpreter::OperandType::kMaybeReg16:
case interpreter::OperandType::kReg16: case interpreter::OperandType::kReg16:
case interpreter::OperandType::kRegOut16:
case interpreter::OperandType::kRegOutPair16:
case interpreter::OperandType::kRegOutTriple16:
case interpreter::OperandType::kRegPair16: case interpreter::OperandType::kRegPair16:
case interpreter::OperandType::kRegTriple16:
EXPECT_THAT(m.BytecodeOperandReg(i), EXPECT_THAT(m.BytecodeOperandReg(i),
m.IsBytecodeOperandShortSignExtended(offset)); m.IsBytecodeOperandShortSignExtended(offset));
break; break;
......
test/unittests/interpreter/bytecodes-unittest.cc
View file @ 95bec7e7
...@@ -43,7 +43,6 @@ TEST(OperandConversion, Registers) { ...@@ -43,7 +43,6 @@ TEST(OperandConversion, Registers) {
} }
} }
TEST(OperandConversion, Parameters) { TEST(OperandConversion, Parameters) {
int parameter_counts[] = {7, 13, 99}; int parameter_counts[] = {7, 13, 99};
...@@ -59,7 +58,6 @@ TEST(OperandConversion, Parameters) { ...@@ -59,7 +58,6 @@ TEST(OperandConversion, Parameters) {
} }
} }
TEST(OperandConversion, RegistersParametersNoOverlap) { TEST(OperandConversion, RegistersParametersNoOverlap) {
int register_count = Register::MaxRegisterIndex() + 1; int register_count = Register::MaxRegisterIndex() + 1;
int parameter_count = Register::MaxParameterIndex() + 1; int parameter_count = Register::MaxParameterIndex() + 1;
...@@ -118,6 +116,46 @@ TEST(Bytecodes, RegisterOperandBitmaps) { ...@@ -118,6 +116,46 @@ TEST(Bytecodes, RegisterOperandBitmaps) {
CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kForInNext), 7); CHECK_EQ(Bytecodes::GetRegisterOperandBitmap(Bytecode::kForInNext), 7);
} }
TEST(Bytecodes, RegisterOperands) {
CHECK(Bytecodes::IsRegisterOperandType(OperandType::kReg8));
CHECK(Bytecodes::IsRegisterInputOperandType(OperandType::kReg8));
CHECK(!Bytecodes::IsRegisterOutputOperandType(OperandType::kReg8));
CHECK(!Bytecodes::IsRegisterInputOperandType(OperandType::kRegOut8));
CHECK(Bytecodes::IsRegisterOutputOperandType(OperandType::kRegOut8));
#define IS_REGISTER_OPERAND_TYPE(Name, _) \
CHECK(Bytecodes::IsRegisterOperandType(OperandType::k##Name));
REGISTER_OPERAND_TYPE_LIST(IS_REGISTER_OPERAND_TYPE)
#undef IS_REGISTER_OPERAND_TYPE
#define IS_NOT_REGISTER_OPERAND_TYPE(Name, _) \
CHECK(!Bytecodes::IsRegisterOperandType(OperandType::k##Name));
NON_REGISTER_OPERAND_TYPE_LIST(IS_NOT_REGISTER_OPERAND_TYPE)
#undef IS_NOT_REGISTER_OPERAND_TYPE
#define IS_REGISTER_INPUT_OPERAND_TYPE(Name, _) \
CHECK(Bytecodes::IsRegisterInputOperandType(OperandType::k##Name));
REGISTER_INPUT_OPERAND_TYPE_LIST(IS_REGISTER_INPUT_OPERAND_TYPE)
#undef IS_REGISTER_INPUT_OPERAND_TYPE
#define IS_NOT_REGISTER_INPUT_OPERAND_TYPE(Name, _) \
CHECK(!Bytecodes::IsRegisterInputOperandType(OperandType::k##Name));
NON_REGISTER_OPERAND_TYPE_LIST(IS_NOT_REGISTER_INPUT_OPERAND_TYPE);
REGISTER_OUTPUT_OPERAND_TYPE_LIST(IS_NOT_REGISTER_INPUT_OPERAND_TYPE)
#undef IS_NOT_REGISTER_INPUT_OPERAND_TYPE
#define IS_REGISTER_OUTPUT_OPERAND_TYPE(Name, _) \
CHECK(Bytecodes::IsRegisterOutputOperandType(OperandType::k##Name));
REGISTER_OUTPUT_OPERAND_TYPE_LIST(IS_REGISTER_OUTPUT_OPERAND_TYPE)
#undef IS_REGISTER_OUTPUT_OPERAND_TYPE
#define IS_NOT_REGISTER_OUTPUT_OPERAND_TYPE(Name, _) \
CHECK(!Bytecodes::IsRegisterOutputOperandType(OperandType::k##Name));
NON_REGISTER_OPERAND_TYPE_LIST(IS_NOT_REGISTER_OUTPUT_OPERAND_TYPE)
REGISTER_INPUT_OPERAND_TYPE_LIST(IS_NOT_REGISTER_OUTPUT_OPERAND_TYPE)
#undef IS_NOT_REGISTER_INPUT_OPERAND_TYPE
}
} // namespace interpreter } // namespace interpreter
} // namespace internal } // namespace internal
} // namespace v8 } // namespace v8
test/unittests/interpreter/register-translator-unittest.cc
View file @ 95bec7e7
...@@ -27,10 +27,14 @@ class RegisterTranslatorTest : public TestWithIsolateAndZone, ...@@ -27,10 +27,14 @@ class RegisterTranslatorTest : public TestWithIsolateAndZone,
~RegisterTranslatorTest() override {} ~RegisterTranslatorTest() override {}
bool PopMoveAndMatch(Register from, Register to) { bool PopMoveAndMatch(Register from, Register to) {
if (!moves_.empty()) {
CHECK(from.is_valid() && to.is_valid()); CHECK(from.is_valid() && to.is_valid());
const std::pair<Register, Register> top = moves_.top(); const std::pair<Register, Register> top = moves_.top();
moves_.pop(); moves_.pop();
return top.first == from && top.second == to; return top.first == from && top.second == to;
} else {
return false;
}
} }
int move_count() const { return move_count_; } int move_count() const { return move_count_; }
...@@ -49,23 +53,6 @@ class RegisterTranslatorTest : public TestWithIsolateAndZone, ...@@ -49,23 +53,6 @@ class RegisterTranslatorTest : public TestWithIsolateAndZone,
move_count_++; move_count_++;
} }
bool RegisterOperandIsMovable(Bytecode bytecode, int operand_index) override {
OperandType operand_type =
Bytecodes::GetOperandType(bytecode, operand_index);
if (operand_type == OperandType::kReg8 ||
operand_type == OperandType::kReg16) {
if (operand_index == Bytecodes::NumberOfOperands(bytecode) - 1) {
return true;
}
OperandType next_operand_type =
Bytecodes::GetOperandType(bytecode, operand_index + 1);
return (next_operand_type != OperandType::kRegCount8 &&
next_operand_type != OperandType::kRegCount16);
} else {
return false;
}
}
RegisterTranslator translator_; RegisterTranslator translator_;
std::stack<std::pair<Register, Register>> moves_; std::stack<std::pair<Register, Register>> moves_;
int move_count_; int move_count_;
...@@ -74,7 +61,8 @@ class RegisterTranslatorTest : public TestWithIsolateAndZone, ...@@ -74,7 +61,8 @@ class RegisterTranslatorTest : public TestWithIsolateAndZone,
}; };
const char* const RegisterTranslatorTest::kBadOperandRegex = const char* const RegisterTranslatorTest::kBadOperandRegex =
".*OperandType::kReg8 && mover\\(\\)->RegisterOperandIsMovable.*"; ".*OperandType::kReg8 \\|\\| .*OperandType::kRegOut8\\) && "
"RegisterIsMovableToWindow.*";
TEST_F(RegisterTranslatorTest, TestFrameSizeAdjustmentsForTranslationWindow) { TEST_F(RegisterTranslatorTest, TestFrameSizeAdjustmentsForTranslationWindow) {
EXPECT_EQ(0, RegisterTranslator::RegisterCountAdjustment(0, 0)); EXPECT_EQ(0, RegisterTranslator::RegisterCountAdjustment(0, 0));
...@@ -157,7 +145,7 @@ TEST_F(RegisterTranslatorTest, NoTranslationRequired) { ...@@ -157,7 +145,7 @@ TEST_F(RegisterTranslatorTest, NoTranslationRequired) {
Register param_reg = Register::FromParameterIndex(129, 130); Register param_reg = Register::FromParameterIndex(129, 130);
operands[0] = param_reg.ToRawOperand(); operands[0] = param_reg.ToRawOperand();
translator()->TranslateInputRegisters(Bytecode::kLdar, operands, 1); translator()->TranslateInputRegisters(Bytecode::kAdd, operands, 1);
translator()->TranslateOutputRegisters(); translator()->TranslateOutputRegisters();
EXPECT_EQ(0, move_count()); EXPECT_EQ(0, move_count());
} }
...@@ -172,6 +160,14 @@ TEST_F(RegisterTranslatorTest, TranslationRequired) { ...@@ -172,6 +160,14 @@ TEST_F(RegisterTranslatorTest, TranslationRequired) {
EXPECT_EQ(1, move_count()); EXPECT_EQ(1, move_count());
EXPECT_TRUE(PopMoveAndMatch(local_reg_translated, window_reg)); EXPECT_TRUE(PopMoveAndMatch(local_reg_translated, window_reg));
translator()->TranslateOutputRegisters(); translator()->TranslateOutputRegisters();
EXPECT_EQ(1, move_count());
EXPECT_FALSE(PopMoveAndMatch(window_reg, local_reg_translated));
operands[0] = local_reg.ToRawOperand();
translator()->TranslateInputRegisters(Bytecode::kStar, operands, 1);
EXPECT_EQ(1, move_count());
EXPECT_FALSE(PopMoveAndMatch(local_reg_translated, window_reg));
translator()->TranslateOutputRegisters();
EXPECT_EQ(2, move_count()); EXPECT_EQ(2, move_count());
EXPECT_TRUE(PopMoveAndMatch(window_reg, local_reg_translated)); EXPECT_TRUE(PopMoveAndMatch(window_reg, local_reg_translated));
...@@ -181,6 +177,14 @@ TEST_F(RegisterTranslatorTest, TranslationRequired) { ...@@ -181,6 +177,14 @@ TEST_F(RegisterTranslatorTest, TranslationRequired) {
EXPECT_EQ(3, move_count()); EXPECT_EQ(3, move_count());
EXPECT_TRUE(PopMoveAndMatch(param_reg, window_reg)); EXPECT_TRUE(PopMoveAndMatch(param_reg, window_reg));
translator()->TranslateOutputRegisters(); translator()->TranslateOutputRegisters();
EXPECT_EQ(3, move_count());
EXPECT_FALSE(PopMoveAndMatch(window_reg, param_reg));
operands[0] = {param_reg.ToRawOperand()};
translator()->TranslateInputRegisters(Bytecode::kStar, operands, 1);
EXPECT_EQ(3, move_count());
EXPECT_FALSE(PopMoveAndMatch(local_reg_translated, window_reg));
translator()->TranslateOutputRegisters();
EXPECT_EQ(4, move_count()); EXPECT_EQ(4, move_count());
EXPECT_TRUE(PopMoveAndMatch(window_reg, param_reg)); EXPECT_TRUE(PopMoveAndMatch(window_reg, param_reg));
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment