src/interpreter/bytecodes.h - Issue 1783483002: [interpreter] Add support for scalable operands.

Unified Diff: src/interpreter/bytecodes.h

Issue 1783483002: [interpreter] Add support for scalable operands. (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master

Patch Set: Incorporate latest review comments from rmcilroy. Created 4 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/interpreter/bytecodes.h

diff --git a/src/interpreter/bytecodes.h b/src/interpreter/bytecodes.h

index bd8ad811987b47d8c183e56462aa6b1fecc73c00..4612f2f25eda4fed21dc3dfeda46647e0ae5d0d7 100644

--- a/src/interpreter/bytecodes.h

+++ b/src/interpreter/bytecodes.h

@@ -15,37 +15,24 @@ namespace v8 {

namespace internal {

namespace interpreter {

-#define INVALID_OPERAND_TYPE_LIST(V) \

- V(None, OperandSize::kNone)

-#define REGISTER_INPUT_OPERAND_TYPE_LIST(V) \

- /* Byte operands. */ \

- V(MaybeReg8, OperandSize::kByte) \

- V(Reg8, OperandSize::kByte) \

- V(RegPair8, OperandSize::kByte) \

- /* Short operands. */ \

- V(MaybeReg16, OperandSize::kShort) \

- V(Reg16, OperandSize::kShort) \

- V(RegPair16, 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) \

- /* Byte operands. */ \

- V(Idx8, OperandSize::kByte) \

- V(Imm8, OperandSize::kByte) \

- V(RegCount8, OperandSize::kByte) \

- /* Short operands. */ \

- V(Idx16, OperandSize::kShort) \

- V(RegCount16, OperandSize::kShort)

+#define INVALID_OPERAND_TYPE_LIST(V) V(None, OperandTypeInfo::kNone)

+#define REGISTER_INPUT_OPERAND_TYPE_LIST(V) \

+ V(MaybeReg, OperandTypeInfo::kScalableSignedByte) \

+ V(Reg, OperandTypeInfo::kScalableSignedByte) \

+ V(RegPair, OperandTypeInfo::kScalableSignedByte)

+#define REGISTER_OUTPUT_OPERAND_TYPE_LIST(V) \

+ V(RegOut, OperandTypeInfo::kScalableSignedByte) \

+ V(RegOutPair, OperandTypeInfo::kScalableSignedByte) \

+ V(RegOutTriple, OperandTypeInfo::kScalableSignedByte)

+#define SCALAR_OPERAND_TYPE_LIST(V) \

+ V(Flag8, OperandTypeInfo::kFixedUnsignedByte) \

+ V(Idx, OperandTypeInfo::kScalableUnsignedByte) \

+ V(Imm, OperandTypeInfo::kScalableSignedByte) \

+ V(RegCount, OperandTypeInfo::kScalableUnsignedByte) \

+ V(RuntimeId, OperandTypeInfo::kFixedUnsignedShort)

#define REGISTER_OPERAND_TYPE_LIST(V) \

REGISTER_INPUT_OPERAND_TYPE_LIST(V) \

@@ -60,235 +47,225 @@ namespace interpreter {

NON_REGISTER_OPERAND_TYPE_LIST(V) \

REGISTER_OPERAND_TYPE_LIST(V)

-// Define one debug break bytecode for each operands size.

-#define DEBUG_BREAK_BYTECODE_LIST(V) \

- V(DebugBreak0, OperandType::kNone) \

- V(DebugBreak1, OperandType::kReg8) \

- V(DebugBreak2, OperandType::kReg16) \

- V(DebugBreak3, OperandType::kReg16, OperandType::kReg8) \

- V(DebugBreak4, OperandType::kReg16, OperandType::kReg16) \

- V(DebugBreak5, OperandType::kReg16, OperandType::kReg16, OperandType::kReg8) \

- V(DebugBreak6, OperandType::kReg16, OperandType::kReg16, \

- OperandType::kReg16) \

- V(DebugBreak7, OperandType::kReg16, OperandType::kReg16, \

- OperandType::kReg16, OperandType::kReg8) \

- V(DebugBreak8, OperandType::kReg16, OperandType::kReg16, \

- OperandType::kReg16, OperandType::kReg16)

+// Define one debug break bytecode for each possible size of unscaled

+// bytecodes.

+#define DEBUG_BREAK_PLAIN_BYTECODE_LIST(V) \

+ V(DebugBreak0, OperandType::kNone) \

+ V(DebugBreak1, OperandType::kReg) \

+ V(DebugBreak2, OperandType::kReg, OperandType::kReg) \

+ V(DebugBreak3, OperandType::kReg, OperandType::kReg, OperandType::kReg) \

+ V(DebugBreak4, OperandType::kReg, OperandType::kReg, OperandType::kReg, \

+ OperandType::kReg) \

+ V(DebugBreak5, OperandType::kRuntimeId, OperandType::kReg, \

+ OperandType::kReg) \

+ V(DebugBreak6, OperandType::kRuntimeId, OperandType::kReg, \

+ OperandType::kReg, OperandType::kReg)

+// Define one debug break for each widening prefix.

+#define DEBUG_BREAK_PREFIX_BYTECODE_LIST(V) \

+ V(DebugBreakWide, OperandType::kNone) \

+ V(DebugBreakExtraWide, OperandType::kNone)

+#define DEBUG_BREAK_BYTECODE_LIST(V) \

+ DEBUG_BREAK_PLAIN_BYTECODE_LIST(V) \

+ DEBUG_BREAK_PREFIX_BYTECODE_LIST(V)

// The list of bytecodes which are interpreted by the interpreter.

-#define BYTECODE_LIST(V) \

- \

- /* Loading the accumulator */ \

- V(LdaZero, OperandType::kNone) \

- V(LdaSmi8, OperandType::kImm8) \

- V(LdaUndefined, OperandType::kNone) \

- V(LdaNull, OperandType::kNone) \

- V(LdaTheHole, OperandType::kNone) \

- V(LdaTrue, OperandType::kNone) \

- V(LdaFalse, OperandType::kNone) \

- V(LdaConstant, OperandType::kIdx8) \

- V(LdaConstantWide, OperandType::kIdx16) \

- \

- /* Globals */ \

- V(LdaGlobal, OperandType::kIdx8, OperandType::kIdx8) \

- V(LdaGlobalInsideTypeof, OperandType::kIdx8, OperandType::kIdx8) \

- V(LdaGlobalWide, OperandType::kIdx16, OperandType::kIdx16) \

- V(LdaGlobalInsideTypeofWide, OperandType::kIdx16, OperandType::kIdx16) \

- V(StaGlobalSloppy, OperandType::kIdx8, OperandType::kIdx8) \

- V(StaGlobalStrict, OperandType::kIdx8, OperandType::kIdx8) \

- V(StaGlobalSloppyWide, OperandType::kIdx16, OperandType::kIdx16) \

- V(StaGlobalStrictWide, OperandType::kIdx16, OperandType::kIdx16) \

- \

- /* Context operations */ \

- V(PushContext, OperandType::kReg8) \

- V(PopContext, OperandType::kReg8) \

- V(LdaContextSlot, OperandType::kReg8, OperandType::kIdx8) \

- V(StaContextSlot, OperandType::kReg8, OperandType::kIdx8) \

- V(LdaContextSlotWide, OperandType::kReg8, OperandType::kIdx16) \

- V(StaContextSlotWide, OperandType::kReg8, OperandType::kIdx16) \

- \

- /* Load-Store lookup slots */ \

- V(LdaLookupSlot, OperandType::kIdx8) \

- V(LdaLookupSlotInsideTypeof, OperandType::kIdx8) \

- V(LdaLookupSlotWide, OperandType::kIdx16) \

- V(LdaLookupSlotInsideTypeofWide, OperandType::kIdx16) \

- V(StaLookupSlotSloppy, OperandType::kIdx8) \

- V(StaLookupSlotStrict, OperandType::kIdx8) \

- V(StaLookupSlotSloppyWide, OperandType::kIdx16) \

- V(StaLookupSlotStrictWide, OperandType::kIdx16) \

- \

- /* Register-accumulator transfers */ \

- V(Ldar, OperandType::kReg8) \

- V(Star, OperandType::kRegOut8) \

- \

- /* Register-register transfers */ \

- V(Mov, OperandType::kReg8, OperandType::kRegOut8) \

- V(MovWide, OperandType::kReg16, OperandType::kRegOut16) \

- \

- /* LoadIC operations */ \

- V(LoadIC, OperandType::kReg8, OperandType::kIdx8, OperandType::kIdx8) \

- V(KeyedLoadIC, OperandType::kReg8, OperandType::kIdx8) \

- V(LoadICWide, OperandType::kReg8, OperandType::kIdx16, OperandType::kIdx16) \

- V(KeyedLoadICWide, OperandType::kReg8, OperandType::kIdx16) \

- \

- /* StoreIC operations */ \

- V(StoreICSloppy, OperandType::kReg8, OperandType::kIdx8, OperandType::kIdx8) \

- V(StoreICStrict, OperandType::kReg8, OperandType::kIdx8, OperandType::kIdx8) \

- V(KeyedStoreICSloppy, OperandType::kReg8, OperandType::kReg8, \

- OperandType::kIdx8) \

- V(KeyedStoreICStrict, OperandType::kReg8, OperandType::kReg8, \

- OperandType::kIdx8) \

- V(StoreICSloppyWide, OperandType::kReg8, OperandType::kIdx16, \

- OperandType::kIdx16) \

- V(StoreICStrictWide, OperandType::kReg8, OperandType::kIdx16, \

- OperandType::kIdx16) \

- V(KeyedStoreICSloppyWide, OperandType::kReg8, OperandType::kReg8, \

- OperandType::kIdx16) \

- V(KeyedStoreICStrictWide, OperandType::kReg8, OperandType::kReg8, \

- OperandType::kIdx16) \

- \

- /* Binary Operators */ \

- V(Add, OperandType::kReg8) \

- V(Sub, OperandType::kReg8) \

- V(Mul, OperandType::kReg8) \

- V(Div, OperandType::kReg8) \

- V(Mod, OperandType::kReg8) \

- V(BitwiseOr, OperandType::kReg8) \

- V(BitwiseXor, OperandType::kReg8) \

- V(BitwiseAnd, OperandType::kReg8) \

- V(ShiftLeft, OperandType::kReg8) \

- V(ShiftRight, OperandType::kReg8) \

- V(ShiftRightLogical, OperandType::kReg8) \

- \

- /* Unary Operators */ \

- V(Inc, OperandType::kNone) \

- V(Dec, OperandType::kNone) \

- V(LogicalNot, OperandType::kNone) \

- V(TypeOf, OperandType::kNone) \

- V(DeletePropertyStrict, OperandType::kReg8) \

- V(DeletePropertySloppy, OperandType::kReg8) \

- \

- /* Call operations */ \

- V(Call, OperandType::kReg8, OperandType::kReg8, OperandType::kRegCount8, \

- OperandType::kIdx8) \

- V(CallWide, OperandType::kReg16, OperandType::kReg16, \

- OperandType::kRegCount16, OperandType::kIdx16) \

- V(TailCall, OperandType::kReg8, OperandType::kReg8, OperandType::kRegCount8, \

- OperandType::kIdx8) \

- V(TailCallWide, OperandType::kReg16, OperandType::kReg16, \

- OperandType::kRegCount16, OperandType::kIdx16) \

- V(CallRuntime, OperandType::kIdx16, OperandType::kMaybeReg8, \

- OperandType::kRegCount8) \

- V(CallRuntimeWide, OperandType::kIdx16, OperandType::kMaybeReg16, \

- OperandType::kRegCount8) \

- V(CallRuntimeForPair, OperandType::kIdx16, OperandType::kMaybeReg8, \

- OperandType::kRegCount8, OperandType::kRegOutPair8) \

- V(CallRuntimeForPairWide, OperandType::kIdx16, OperandType::kMaybeReg16, \

- OperandType::kRegCount8, OperandType::kRegOutPair16) \

- V(CallJSRuntime, OperandType::kIdx16, OperandType::kReg8, \

- OperandType::kRegCount8) \

- V(CallJSRuntimeWide, OperandType::kIdx16, OperandType::kReg16, \

- OperandType::kRegCount16) \

- \

- /* New operator */ \

- V(New, OperandType::kReg8, OperandType::kMaybeReg8, OperandType::kRegCount8) \

- V(NewWide, OperandType::kReg16, OperandType::kMaybeReg16, \

- OperandType::kRegCount16) \

- \

- /* Test Operators */ \

- V(TestEqual, OperandType::kReg8) \

- V(TestNotEqual, OperandType::kReg8) \

- V(TestEqualStrict, OperandType::kReg8) \

- V(TestLessThan, OperandType::kReg8) \

- V(TestGreaterThan, OperandType::kReg8) \

- V(TestLessThanOrEqual, OperandType::kReg8) \

- V(TestGreaterThanOrEqual, OperandType::kReg8) \

- V(TestInstanceOf, OperandType::kReg8) \

- V(TestIn, OperandType::kReg8) \

- \

- /* Cast operators */ \

- V(ToName, OperandType::kNone) \

- V(ToNumber, OperandType::kNone) \

- V(ToObject, OperandType::kNone) \

- \

- /* Literals */ \

- V(CreateRegExpLiteral, OperandType::kIdx8, OperandType::kIdx8, \

- OperandType::kImm8) \

- V(CreateArrayLiteral, OperandType::kIdx8, OperandType::kIdx8, \

- OperandType::kImm8) \

- V(CreateObjectLiteral, OperandType::kIdx8, OperandType::kIdx8, \

- OperandType::kImm8) \

- V(CreateRegExpLiteralWide, OperandType::kIdx16, OperandType::kIdx16, \

- OperandType::kImm8) \

- V(CreateArrayLiteralWide, OperandType::kIdx16, OperandType::kIdx16, \

- OperandType::kImm8) \

- V(CreateObjectLiteralWide, OperandType::kIdx16, OperandType::kIdx16, \

- OperandType::kImm8) \

- \

- /* Closure allocation */ \

- V(CreateClosure, OperandType::kIdx8, OperandType::kImm8) \

- V(CreateClosureWide, OperandType::kIdx16, OperandType::kImm8) \

- \

- /* Arguments allocation */ \

- V(CreateMappedArguments, OperandType::kNone) \

- V(CreateUnmappedArguments, OperandType::kNone) \

- V(CreateRestParameter, OperandType::kNone) \

- \

- /* Control Flow */ \

- V(Jump, OperandType::kImm8) \

- V(JumpConstant, OperandType::kIdx8) \

- V(JumpConstantWide, OperandType::kIdx16) \

- V(JumpIfTrue, OperandType::kImm8) \

- V(JumpIfTrueConstant, OperandType::kIdx8) \

- V(JumpIfTrueConstantWide, OperandType::kIdx16) \

- V(JumpIfFalse, OperandType::kImm8) \

- V(JumpIfFalseConstant, OperandType::kIdx8) \

- V(JumpIfFalseConstantWide, OperandType::kIdx16) \

- V(JumpIfToBooleanTrue, OperandType::kImm8) \

- V(JumpIfToBooleanTrueConstant, OperandType::kIdx8) \

- V(JumpIfToBooleanTrueConstantWide, OperandType::kIdx16) \

- V(JumpIfToBooleanFalse, OperandType::kImm8) \

- V(JumpIfToBooleanFalseConstant, OperandType::kIdx8) \

- V(JumpIfToBooleanFalseConstantWide, OperandType::kIdx16) \

- V(JumpIfNull, OperandType::kImm8) \

- V(JumpIfNullConstant, OperandType::kIdx8) \

- V(JumpIfNullConstantWide, OperandType::kIdx16) \

- V(JumpIfUndefined, OperandType::kImm8) \

- V(JumpIfUndefinedConstant, OperandType::kIdx8) \

- V(JumpIfUndefinedConstantWide, OperandType::kIdx16) \

- V(JumpIfNotHole, OperandType::kImm8) \

- V(JumpIfNotHoleConstant, OperandType::kIdx8) \

- V(JumpIfNotHoleConstantWide, OperandType::kIdx16) \

- \

- /* Complex flow control For..in */ \

- V(ForInPrepare, OperandType::kRegOutTriple8) \

- V(ForInPrepareWide, OperandType::kRegOutTriple16) \

- V(ForInDone, OperandType::kReg8, OperandType::kReg8) \

- V(ForInNext, OperandType::kReg8, OperandType::kReg8, OperandType::kRegPair8, \

- OperandType::kIdx8) \

- V(ForInNextWide, OperandType::kReg16, OperandType::kReg16, \

- OperandType::kRegPair16, OperandType::kIdx16) \

- V(ForInStep, OperandType::kReg8) \

- \

- /* Perform a stack guard check */ \

- V(StackCheck, OperandType::kNone) \

- \

- /* Non-local flow control */ \

- V(Throw, OperandType::kNone) \

- V(ReThrow, OperandType::kNone) \

- V(Return, OperandType::kNone) \

- \

- /* Debugger */ \

- V(Debugger, OperandType::kNone) \

- DEBUG_BREAK_BYTECODE_LIST(V)

-// Enumeration of the size classes of operand types used by bytecodes.

+#define BYTECODE_LIST(V) \

+ /* Extended width operands */ \

+ V(Wide, OperandType::kNone) \

+ V(ExtraWide, OperandType::kNone) \

+ \

+ /* Loading the accumulator */ \

+ V(LdaZero, OperandType::kNone) \

+ V(LdaSmi, OperandType::kImm) \

+ V(LdaUndefined, OperandType::kNone) \

+ V(LdaNull, OperandType::kNone) \

+ V(LdaTheHole, OperandType::kNone) \

+ V(LdaTrue, OperandType::kNone) \

+ V(LdaFalse, OperandType::kNone) \

+ V(LdaConstant, OperandType::kIdx) \

+ \

+ /* Globals */ \

+ V(LdaGlobal, OperandType::kIdx, OperandType::kIdx) \

+ V(LdaGlobalInsideTypeof, OperandType::kIdx, OperandType::kIdx) \

+ V(StaGlobalSloppy, OperandType::kIdx, OperandType::kIdx) \

+ V(StaGlobalStrict, OperandType::kIdx, OperandType::kIdx) \

+ \

+ /* Context operations */ \

+ V(PushContext, OperandType::kReg) \

+ V(PopContext, OperandType::kReg) \

+ V(LdaContextSlot, OperandType::kReg, OperandType::kIdx) \

+ V(StaContextSlot, OperandType::kReg, OperandType::kIdx) \

+ \

+ /* Load-Store lookup slots */ \

+ V(LdaLookupSlot, OperandType::kIdx) \

+ V(LdaLookupSlotInsideTypeof, OperandType::kIdx) \

+ V(StaLookupSlotSloppy, OperandType::kIdx) \

+ V(StaLookupSlotStrict, OperandType::kIdx) \

+ \

+ /* Register-accumulator transfers */ \

+ V(Ldar, OperandType::kReg) \

+ V(Star, OperandType::kRegOut) \

+ \

+ /* Register-register transfers */ \

+ V(Mov, OperandType::kReg, OperandType::kRegOut) \

+ \

+ /* LoadIC operations */ \

+ V(LoadIC, OperandType::kReg, OperandType::kIdx, OperandType::kIdx) \

+ V(KeyedLoadIC, OperandType::kReg, OperandType::kIdx) \

+ \

+ /* StoreIC operations */ \

+ V(StoreICSloppy, OperandType::kReg, OperandType::kIdx, OperandType::kIdx) \

+ V(StoreICStrict, OperandType::kReg, OperandType::kIdx, OperandType::kIdx) \

+ V(KeyedStoreICSloppy, OperandType::kReg, OperandType::kReg, \

+ OperandType::kIdx) \

+ V(KeyedStoreICStrict, OperandType::kReg, OperandType::kReg, \

+ OperandType::kIdx) \

+ \

+ /* Binary Operators */ \

+ V(Add, OperandType::kReg) \

+ V(Sub, OperandType::kReg) \

+ V(Mul, OperandType::kReg) \

+ V(Div, OperandType::kReg) \

+ V(Mod, OperandType::kReg) \

+ V(BitwiseOr, OperandType::kReg) \

+ V(BitwiseXor, OperandType::kReg) \

+ V(BitwiseAnd, OperandType::kReg) \

+ V(ShiftLeft, OperandType::kReg) \

+ V(ShiftRight, OperandType::kReg) \

+ V(ShiftRightLogical, OperandType::kReg) \

+ \

+ /* Unary Operators */ \

+ V(Inc, OperandType::kNone) \

+ V(Dec, OperandType::kNone) \

+ V(LogicalNot, OperandType::kNone) \

+ V(TypeOf, OperandType::kNone) \

+ V(DeletePropertyStrict, OperandType::kReg) \

+ V(DeletePropertySloppy, OperandType::kReg) \

+ \

+ /* Call operations */ \

+ V(Call, OperandType::kReg, OperandType::kReg, OperandType::kRegCount, \

+ OperandType::kIdx) \

+ V(TailCall, OperandType::kReg, OperandType::kReg, OperandType::kRegCount, \

+ OperandType::kIdx) \

+ V(CallRuntime, OperandType::kRuntimeId, OperandType::kMaybeReg, \

+ OperandType::kRegCount) \

+ V(CallRuntimeForPair, OperandType::kRuntimeId, OperandType::kMaybeReg, \

+ OperandType::kRegCount, OperandType::kRegOutPair) \

+ V(CallJSRuntime, OperandType::kIdx, OperandType::kReg, \

+ OperandType::kRegCount) \

+ \

+ /* New operator */ \

+ V(New, OperandType::kReg, OperandType::kMaybeReg, OperandType::kRegCount) \

+ \

+ /* Test Operators */ \

+ V(TestEqual, OperandType::kReg) \

+ V(TestNotEqual, OperandType::kReg) \

+ V(TestEqualStrict, OperandType::kReg) \

+ V(TestLessThan, OperandType::kReg) \

+ V(TestGreaterThan, OperandType::kReg) \

+ V(TestLessThanOrEqual, OperandType::kReg) \

+ V(TestGreaterThanOrEqual, OperandType::kReg) \

+ V(TestInstanceOf, OperandType::kReg) \

+ V(TestIn, OperandType::kReg) \

+ \

+ /* Cast operators */ \

+ V(ToName, OperandType::kNone) \

+ V(ToNumber, OperandType::kNone) \

+ V(ToObject, OperandType::kNone) \

+ \

+ /* Literals */ \

+ V(CreateRegExpLiteral, OperandType::kIdx, OperandType::kIdx, \

+ OperandType::kFlag8) \

+ V(CreateArrayLiteral, OperandType::kIdx, OperandType::kIdx, \

+ OperandType::kFlag8) \

+ V(CreateObjectLiteral, OperandType::kIdx, OperandType::kIdx, \

+ OperandType::kFlag8) \

+ \

+ /* Closure allocation */ \

+ V(CreateClosure, OperandType::kIdx, OperandType::kFlag8) \

+ \

+ /* Arguments allocation */ \

+ V(CreateMappedArguments, OperandType::kNone) \

+ V(CreateUnmappedArguments, OperandType::kNone) \

+ V(CreateRestParameter, OperandType::kNone) \

+ \

+ /* Control Flow */ \

+ V(Jump, OperandType::kImm) \

+ V(JumpConstant, OperandType::kIdx) \

+ V(JumpIfTrue, OperandType::kImm) \

+ V(JumpIfTrueConstant, OperandType::kIdx) \

+ V(JumpIfFalse, OperandType::kImm) \

+ V(JumpIfFalseConstant, OperandType::kIdx) \

+ V(JumpIfToBooleanTrue, OperandType::kImm) \

+ V(JumpIfToBooleanTrueConstant, OperandType::kIdx) \

+ V(JumpIfToBooleanFalse, OperandType::kImm) \

+ V(JumpIfToBooleanFalseConstant, OperandType::kIdx) \

+ V(JumpIfNull, OperandType::kImm) \

+ V(JumpIfNullConstant, OperandType::kIdx) \

+ V(JumpIfUndefined, OperandType::kImm) \

+ V(JumpIfUndefinedConstant, OperandType::kIdx) \

+ V(JumpIfNotHole, OperandType::kImm) \

+ V(JumpIfNotHoleConstant, OperandType::kIdx) \

+ \

+ /* Complex flow control For..in */ \

+ V(ForInPrepare, OperandType::kRegOutTriple) \

+ V(ForInDone, OperandType::kReg, OperandType::kReg) \

+ V(ForInNext, OperandType::kReg, OperandType::kReg, OperandType::kRegPair, \

+ OperandType::kIdx) \

+ V(ForInStep, OperandType::kReg) \

+ \

+ /* Perform a stack guard check */ \

+ V(StackCheck, OperandType::kNone) \

+ \

+ /* Non-local flow control */ \

+ V(Throw, OperandType::kNone) \

+ V(ReThrow, OperandType::kNone) \

+ V(Return, OperandType::kNone) \

+ \

+ /* Debugger */ \

+ V(Debugger, OperandType::kNone) \

+ DEBUG_BREAK_BYTECODE_LIST(V) \

+ \

+ /* Illegal bytecode (terminates execution) */ \

+ V(Illegal, OperandType::kNone)

+// Enumeration of scaling factors applicable to scalable operands. Code

+// relies on being able to cast values to integer scaling values.

+enum class OperandScale : uint8_t {

+ kSingle = 1,

+ kDouble = 2,

+ kQuadruple = 4,

+ kMaxValid = kQuadruple,

+ kInvalid = 8,

+};

+// Enumeration of the size classes of operand types used by

+// bytecodes. Code relies on being able to cast values to integer

+// types to get the size in bytes.

enum class OperandSize : uint8_t {

kNone = 0,

kByte = 1,

kShort = 2,

+ kQuad = 4,

+ kLast = kQuad

};

+// Primitive operand info used that summarize properties of operands.

+// Columns are Name, IsScalable, IsUnsigned, UnscaledSize.

+#define OPERAND_TYPE_INFO_LIST(V) \

+ V(None, false, false, OperandSize::kNone) \

+ V(ScalableSignedByte, true, false, OperandSize::kByte) \

+ V(ScalableUnsignedByte, true, true, OperandSize::kByte) \

+ V(FixedUnsignedByte, false, true, OperandSize::kByte) \

+ V(FixedUnsignedShort, false, true, OperandSize::kShort)

+enum class OperandTypeInfo : uint8_t {

+#define DECLARE_OPERAND_TYPE_INFO(Name, ...) k##Name,

+ OPERAND_TYPE_INFO_LIST(DECLARE_OPERAND_TYPE_INFO)

+#undef DECLARE_OPERAND_TYPE_INFO

+};

// Enumeration of operand types used by bytecodes.

enum class OperandType : uint8_t {

@@ -330,9 +307,6 @@ class Register {

static Register FromParameterIndex(int index, int parameter_count);

int ToParameterIndex(int parameter_count) const;

- static int MaxParameterIndex();

- static int MaxRegisterIndex();

- static int MaxRegisterIndexForByteOperand();

// Returns an invalid register.

static Register invalid_value() { return Register(); }

@@ -349,14 +323,8 @@ class Register {

static Register new_target();

bool is_new_target() const;

- static Register FromOperand(uint8_t operand);

- uint8_t ToOperand() const;

- static Register FromWideOperand(uint16_t operand);

- uint16_t ToWideOperand() const;

- static Register FromRawOperand(uint32_t raw_operand);

- uint32_t ToRawOperand() const;

+ int32_t ToOperand() const { return -index_; }

+ static Register FromOperand(int32_t operand) { return Register(-operand); }

static bool AreContiguous(Register reg1, Register reg2,

@@ -399,9 +367,15 @@ class Bytecodes {

// Returns string representation of |bytecode|.

static const char* ToString(Bytecode bytecode);

+ // Returns string representation of |bytecode|.

+ static std::string ToString(Bytecode bytecode, OperandScale operand_scale);

// Returns string representation of |operand_type|.

static const char* OperandTypeToString(OperandType operand_type);

+ // Returns string representation of |operand_scale|.

+ static const char* OperandScaleToString(OperandScale operand_scale);

// Returns string representation of |operand_size|.

static const char* OperandSizeToString(OperandSize operand_size);

@@ -417,57 +391,63 @@ class Bytecodes {

// Returns the number of register operands expected by |bytecode|.

static int NumberOfRegisterOperands(Bytecode bytecode);

+ // Returns the prefix bytecode representing an operand scale to be

+ // applied to a a bytecode.

+ static Bytecode OperandScaleToPrefixBytecode(OperandScale operand_scale);

+ // Returns true if the operand scale requires a prefix bytecode.

+ static bool OperandScaleRequiresPrefixBytecode(OperandScale operand_scale);

+ // Returns the scaling applied to scalable operands if bytecode is

+ // is a scaling prefix.

+ static OperandScale PrefixBytecodeToOperandScale(Bytecode bytecode);

// Returns the i-th operand of |bytecode|.

static OperandType GetOperandType(Bytecode bytecode, int i);

// Returns the size of the i-th operand of |bytecode|.

- static OperandSize GetOperandSize(Bytecode bytecode, int i);

+ static OperandSize GetOperandSize(Bytecode bytecode, int i,

+ OperandScale operand_scale);

// Returns the offset of the i-th operand of |bytecode| relative to the start

// of the bytecode.

- static int GetOperandOffset(Bytecode bytecode, int i);

+ static int GetOperandOffset(Bytecode bytecode, int i,

+ OperandScale operand_scale);

// Returns a zero-based bitmap of the register operand positions of

// |bytecode|.

static int GetRegisterOperandBitmap(Bytecode bytecode);

- // Returns a debug break bytecode with a matching operand size.

+ // Returns a debug break bytecode to replace |bytecode|.

static Bytecode GetDebugBreak(Bytecode bytecode);

- // Returns the size of the bytecode including its operands.

- static int Size(Bytecode bytecode);

+ // Returns the size of the bytecode including its operands for the

+ // given |operand_scale|.

+ static int Size(Bytecode bytecode, OperandScale operand_scale);

// Returns the size of |operand|.

- static OperandSize SizeOfOperand(OperandType operand);

+ static OperandSize SizeOfOperand(OperandType operand, OperandScale scale);

// Returns true if the bytecode is a conditional jump taking

- // an immediate byte operand (OperandType::kImm8).

+ // an immediate byte operand (OperandType::kImm).

static bool IsConditionalJumpImmediate(Bytecode bytecode);

// Returns true if the bytecode is a conditional jump taking

- // a constant pool entry (OperandType::kIdx8).

+ // a constant pool entry (OperandType::kIdx).

static bool IsConditionalJumpConstant(Bytecode bytecode);

// Returns true if the bytecode is a conditional jump taking

- // a constant pool entry (OperandType::kIdx16).

- static bool IsConditionalJumpConstantWide(Bytecode bytecode);

- // Returns true if the bytecode is a conditional jump taking

// any kind of operand.

static bool IsConditionalJump(Bytecode bytecode);

// Returns true if the bytecode is a jump or a conditional jump taking

- // an immediate byte operand (OperandType::kImm8).

+ // an immediate byte operand (OperandType::kImm).

static bool IsJumpImmediate(Bytecode bytecode);

// Returns true if the bytecode is a jump or conditional jump taking a

- // constant pool entry (OperandType::kIdx8).

+ // constant pool entry (OperandType::kIdx).

static bool IsJumpConstant(Bytecode bytecode);

- // Returns true if the bytecode is a jump or conditional jump taking a

- // constant pool entry (OperandType::kIdx16).

- static bool IsJumpConstantWide(Bytecode bytecode);

// Returns true if the bytecode is a jump or conditional jump taking

// any kind of operand.

static bool IsJump(Bytecode bytecode);

@@ -484,15 +464,11 @@ class Bytecodes {

// Returns true if the bytecode is a debug break.

static bool IsDebugBreak(Bytecode bytecode);

- // Returns true if |operand_type| is a register index operand (kIdx8/kIdx16).

- static bool IsIndexOperandType(OperandType operand_type);

- // Returns true if |operand_type| represents an immediate.

- static bool IsImmediateOperandType(OperandType operand_type);

+ // Returns true if the bytecode has wider operand forms.

+ static bool IsBytecodeWithScalableOperands(Bytecode bytecode);

- // Returns true if |operand_type| is a register count operand

- // (kRegCount8/kRegCount16).

- static bool IsRegisterCountOperandType(OperandType operand_type);

+ // Returns true if the bytecode is a scaling prefix bytecode.

+ static bool IsPrefixScalingBytecode(Bytecode bytecode);

// Returns true if |operand_type| is any type of register operand.

static bool IsRegisterOperandType(OperandType operand_type);

@@ -504,20 +480,45 @@ class Bytecodes {

static bool IsRegisterOutputOperandType(OperandType operand_type);

// Returns true if |operand_type| is a maybe register operand

- // (kMaybeReg8/kMaybeReg16).

+ // (kMaybeReg).

static bool IsMaybeRegisterOperandType(OperandType operand_type);

+ // Returns true if |operand_type| is a runtime-id operand (kRuntimeId).

+ static bool IsRuntimeIdOperandType(OperandType operand_type);

+ // Returns true if |operand_type| is unsigned, false if signed.

+ static bool IsUnsignedOperandType(OperandType operand_type);

+ // Decodes a register operand in a byte array.

+ static Register DecodeRegisterOperand(const uint8_t* operand_start,

+ OperandType operand_type,

+ OperandScale operand_scale);

+ // Decodes a signed operand in a byte array.

+ static int32_t DecodeSignedOperand(const uint8_t* operand_start,

+ OperandType operand_type,

+ OperandScale operand_scale);

+ // Decodes an unsigned operand in a byte array.

+ static uint32_t DecodeUnsignedOperand(const uint8_t* operand_start,

+ OperandType operand_type,

+ OperandScale operand_scale);

// Decode a single bytecode and operands to |os|.

static std::ostream& Decode(std::ostream& os, const uint8_t* bytecode_start,

int number_of_parameters);

+ // Return the next larger operand scale.

+ static OperandScale NextOperandScale(OperandScale operand_scale);

private:

DISALLOW_IMPLICIT_CONSTRUCTORS(Bytecodes);

};

std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode);

+std::ostream& operator<<(std::ostream& os, const OperandScale& operand_scale);

+std::ostream& operator<<(std::ostream& os, const OperandSize& operand_size);

std::ostream& operator<<(std::ostream& os, const OperandType& operand_type);

-std::ostream& operator<<(std::ostream& os, const OperandSize& operand_type);

} // namespace interpreter

} // namespace internal

« src/interpreter/bytecode-array-builder.cc ('K') | « src/interpreter/bytecode-traits.h ('k') | src/interpreter/bytecodes.cc » ('j') | src/interpreter/interpreter-assembler.h » ('J')