diff options
Diffstat (limited to 'deps/v8/src/arm/lithium-arm.h')
| -rw-r--r-- | deps/v8/src/arm/lithium-arm.h | 570 |
1 files changed, 419 insertions, 151 deletions
diff --git a/deps/v8/src/arm/lithium-arm.h b/deps/v8/src/arm/lithium-arm.h index 77d6b71a9..c864d20f3 100644 --- a/deps/v8/src/arm/lithium-arm.h +++ b/deps/v8/src/arm/lithium-arm.h @@ -32,6 +32,7 @@ #include "lithium-allocator.h" #include "lithium.h" #include "safepoint-table.h" +#include "utils.h" namespace v8 { namespace internal { @@ -69,18 +70,23 @@ class LCodeGen; V(CallStub) \ V(CheckFunction) \ V(CheckInstanceType) \ + V(CheckNonSmi) \ V(CheckMap) \ V(CheckPrototypeMaps) \ V(CheckSmi) \ + V(ClampDToUint8) \ + V(ClampIToUint8) \ + V(ClampTToUint8) \ V(ClassOfTest) \ V(ClassOfTestAndBranch) \ + V(CmpConstantEq) \ + V(CmpConstantEqAndBranch) \ V(CmpID) \ V(CmpIDAndBranch) \ - V(CmpJSObjectEq) \ - V(CmpJSObjectEqAndBranch) \ + V(CmpObjectEq) \ + V(CmpObjectEqAndBranch) \ V(CmpMapAndBranch) \ V(CmpT) \ - V(CmpTAndBranch) \ V(ConstantD) \ V(ConstantI) \ V(ConstantT) \ @@ -89,9 +95,10 @@ class LCodeGen; V(Deoptimize) \ V(DivI) \ V(DoubleToI) \ + V(ElementsKind) \ + V(ExternalArrayLength) \ V(FixedArrayLength) \ V(FunctionLiteral) \ - V(Gap) \ V(GetCachedArrayIndex) \ V(GlobalObject) \ V(GlobalReceiver) \ @@ -100,29 +107,37 @@ class LCodeGen; V(HasCachedArrayIndexAndBranch) \ V(HasInstanceType) \ V(HasInstanceTypeAndBranch) \ + V(In) \ V(InstanceOf) \ - V(InstanceOfAndBranch) \ V(InstanceOfKnownGlobal) \ + V(InstructionGap) \ V(Integer32ToDouble) \ + V(InvokeFunction) \ + V(IsConstructCall) \ + V(IsConstructCallAndBranch) \ V(IsNull) \ V(IsNullAndBranch) \ V(IsObject) \ V(IsObjectAndBranch) \ V(IsSmi) \ V(IsSmiAndBranch) \ + V(IsUndetectable) \ + V(IsUndetectableAndBranch) \ V(JSArrayLength) \ V(Label) \ V(LazyBailout) \ V(LoadContextSlot) \ V(LoadElements) \ + V(LoadExternalArrayPointer) \ V(LoadFunctionPrototype) \ - V(LoadGlobal) \ + V(LoadGlobalCell) \ + V(LoadGlobalGeneric) \ V(LoadKeyedFastElement) \ V(LoadKeyedGeneric) \ + V(LoadKeyedSpecializedArrayElement) \ V(LoadNamedField) \ + V(LoadNamedFieldPolymorphic) \ V(LoadNamedGeneric) \ - V(LoadPixelArrayElement) \ - V(LoadPixelArrayExternalPointer) \ V(ModI) \ V(MulI) \ V(NumberTagD) \ @@ -132,7 +147,6 @@ class LCodeGen; V(OsrEntry) \ V(OuterContext) \ V(Parameter) \ - V(PixelArrayLength) \ V(Power) \ V(PushArgument) \ V(RegExpLiteral) \ @@ -142,40 +156,40 @@ class LCodeGen; V(SmiUntag) \ V(StackCheck) \ V(StoreContextSlot) \ - V(StoreGlobal) \ + V(StoreGlobalCell) \ + V(StoreGlobalGeneric) \ V(StoreKeyedFastElement) \ V(StoreKeyedGeneric) \ + V(StoreKeyedSpecializedArrayElement) \ V(StoreNamedField) \ V(StoreNamedGeneric) \ + V(StringAdd) \ V(StringCharCodeAt) \ + V(StringCharFromCode) \ V(StringLength) \ V(SubI) \ V(TaggedToI) \ + V(ThisFunction) \ V(Throw) \ + V(ToFastProperties) \ V(Typeof) \ V(TypeofIs) \ V(TypeofIsAndBranch) \ - V(IsConstructCall) \ - V(IsConstructCallAndBranch) \ V(UnaryMathOperation) \ V(UnknownOSRValue) \ V(ValueOf) -#define DECLARE_INSTRUCTION(type) \ - virtual bool Is##type() const { return true; } \ - static L##type* cast(LInstruction* instr) { \ - ASSERT(instr->Is##type()); \ - return reinterpret_cast<L##type*>(instr); \ +#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \ + virtual Opcode opcode() const { return LInstruction::k##type; } \ + virtual void CompileToNative(LCodeGen* generator); \ + virtual const char* Mnemonic() const { return mnemonic; } \ + static L##type* cast(LInstruction* instr) { \ + ASSERT(instr->Is##type()); \ + return reinterpret_cast<L##type*>(instr); \ } -#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \ - virtual void CompileToNative(LCodeGen* generator); \ - virtual const char* Mnemonic() const { return mnemonic; } \ - DECLARE_INSTRUCTION(type) - - #define DECLARE_HYDROGEN_ACCESSOR(type) \ H##type* hydrogen() const { \ return H##type::cast(hydrogen_value()); \ @@ -197,10 +211,25 @@ class LInstruction: public ZoneObject { virtual void PrintDataTo(StringStream* stream) = 0; virtual void PrintOutputOperandTo(StringStream* stream) = 0; - // Declare virtual type testers. -#define DECLARE_DO(type) virtual bool Is##type() const { return false; } - LITHIUM_ALL_INSTRUCTION_LIST(DECLARE_DO) -#undef DECLARE_DO + enum Opcode { + // Declare a unique enum value for each instruction. +#define DECLARE_OPCODE(type) k##type, + LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE) + kNumberOfInstructions +#undef DECLARE_OPCODE + }; + + virtual Opcode opcode() const = 0; + + // Declare non-virtual type testers for all leaf IR classes. +#define DECLARE_PREDICATE(type) \ + bool Is##type() const { return opcode() == k##type; } + LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE) +#undef DECLARE_PREDICATE + + // Declare virtual predicates for instructions that don't have + // an opcode. + virtual bool IsGap() const { return false; } virtual bool IsControl() const { return false; } virtual void SetBranchTargets(int true_block_id, int false_block_id) { } @@ -258,37 +287,6 @@ class LInstruction: public ZoneObject { }; -template<typename ElementType, int NumElements> -class OperandContainer { - public: - OperandContainer() { - for (int i = 0; i < NumElements; i++) elems_[i] = NULL; - } - int length() { return NumElements; } - ElementType& operator[](int i) { - ASSERT(i < length()); - return elems_[i]; - } - void PrintOperandsTo(StringStream* stream); - - private: - ElementType elems_[NumElements]; -}; - - -template<typename ElementType> -class OperandContainer<ElementType, 0> { - public: - int length() { return 0; } - void PrintOperandsTo(StringStream* stream) { } - ElementType& operator[](int i) { - UNREACHABLE(); - static ElementType t = 0; - return t; - } -}; - - // R = number of result operands (0 or 1). // I = number of input operands. // T = number of temporary operands. @@ -311,9 +309,9 @@ class LTemplateInstruction: public LInstruction { virtual void PrintOutputOperandTo(StringStream* stream); protected: - OperandContainer<LOperand*, R> results_; - OperandContainer<LOperand*, I> inputs_; - OperandContainer<LOperand*, T> temps_; + EmbeddedContainer<LOperand*, R> results_; + EmbeddedContainer<LOperand*, I> inputs_; + EmbeddedContainer<LOperand*, T> temps_; }; @@ -327,8 +325,13 @@ class LGap: public LTemplateInstruction<0, 0, 0> { parallel_moves_[AFTER] = NULL; } - DECLARE_CONCRETE_INSTRUCTION(Gap, "gap") - virtual void PrintDataTo(StringStream* stream) const; + // Can't use the DECLARE-macro here because of sub-classes. + virtual bool IsGap() const { return true; } + virtual void PrintDataTo(StringStream* stream); + static LGap* cast(LInstruction* instr) { + ASSERT(instr->IsGap()); + return reinterpret_cast<LGap*>(instr); + } bool IsRedundant() const; @@ -358,21 +361,26 @@ class LGap: public LTemplateInstruction<0, 0, 0> { }; +class LInstructionGap: public LGap { + public: + explicit LInstructionGap(HBasicBlock* block) : LGap(block) { } + + DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap") +}; + + class LGoto: public LTemplateInstruction<0, 0, 0> { public: - LGoto(int block_id, bool include_stack_check = false) - : block_id_(block_id), include_stack_check_(include_stack_check) { } + explicit LGoto(int block_id) : block_id_(block_id) { } DECLARE_CONCRETE_INSTRUCTION(Goto, "goto") virtual void PrintDataTo(StringStream* stream); virtual bool IsControl() const { return true; } int block_id() const { return block_id_; } - bool include_stack_check() const { return include_stack_check_; } private: int block_id_; - bool include_stack_check_; }; @@ -446,7 +454,6 @@ class LUnknownOSRValue: public LTemplateInstruction<1, 0, 0> { template<int I, int T> class LControlInstruction: public LTemplateInstruction<0, I, T> { public: - DECLARE_INSTRUCTION(ControlInstruction) virtual bool IsControl() const { return true; } int true_block_id() const { return true_block_id_; } @@ -519,11 +526,29 @@ class LArgumentsElements: public LTemplateInstruction<1, 0, 0> { }; -class LModI: public LTemplateInstruction<1, 2, 0> { +class LModI: public LTemplateInstruction<1, 2, 3> { public: - LModI(LOperand* left, LOperand* right) { + // Used when the right hand is a constant power of 2. + LModI(LOperand* left, + LOperand* right) { inputs_[0] = left; inputs_[1] = right; + temps_[0] = NULL; + temps_[1] = NULL; + temps_[2] = NULL; + } + + // Used for the standard case. + LModI(LOperand* left, + LOperand* right, + LOperand* temp1, + LOperand* temp2, + LOperand* temp3) { + inputs_[0] = left; + inputs_[1] = right; + temps_[0] = temp1; + temps_[1] = temp2; + temps_[2] = temp3; } DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i") @@ -607,26 +632,49 @@ class LUnaryMathOperation: public LTemplateInstruction<1, 1, 1> { }; -class LCmpJSObjectEq: public LTemplateInstruction<1, 2, 0> { +class LCmpObjectEq: public LTemplateInstruction<1, 2, 0> { public: - LCmpJSObjectEq(LOperand* left, LOperand* right) { + LCmpObjectEq(LOperand* left, LOperand* right) { inputs_[0] = left; inputs_[1] = right; } - DECLARE_CONCRETE_INSTRUCTION(CmpJSObjectEq, "cmp-jsobject-eq") + DECLARE_CONCRETE_INSTRUCTION(CmpObjectEq, "cmp-object-eq") }; -class LCmpJSObjectEqAndBranch: public LControlInstruction<2, 0> { +class LCmpObjectEqAndBranch: public LControlInstruction<2, 0> { public: - LCmpJSObjectEqAndBranch(LOperand* left, LOperand* right) { + LCmpObjectEqAndBranch(LOperand* left, LOperand* right) { inputs_[0] = left; inputs_[1] = right; } - DECLARE_CONCRETE_INSTRUCTION(CmpJSObjectEqAndBranch, - "cmp-jsobject-eq-and-branch") + DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, + "cmp-object-eq-and-branch") +}; + + +class LCmpConstantEq: public LTemplateInstruction<1, 1, 0> { + public: + explicit LCmpConstantEq(LOperand* left) { + inputs_[0] = left; + } + + DECLARE_CONCRETE_INSTRUCTION(CmpConstantEq, "cmp-constant-eq") + DECLARE_HYDROGEN_ACCESSOR(CompareConstantEq) +}; + + +class LCmpConstantEqAndBranch: public LControlInstruction<1, 0> { + public: + explicit LCmpConstantEqAndBranch(LOperand* left) { + inputs_[0] = left; + } + + DECLARE_CONCRETE_INSTRUCTION(CmpConstantEqAndBranch, + "cmp-constant-eq-and-branch") + DECLARE_HYDROGEN_ACCESSOR(CompareConstantEq) }; @@ -657,7 +705,7 @@ class LIsNullAndBranch: public LControlInstruction<1, 0> { }; -class LIsObject: public LTemplateInstruction<1, 1, 1> { +class LIsObject: public LTemplateInstruction<1, 1, 0> { public: explicit LIsObject(LOperand* value) { inputs_[0] = value; @@ -667,7 +715,7 @@ class LIsObject: public LTemplateInstruction<1, 1, 1> { }; -class LIsObjectAndBranch: public LControlInstruction<1, 2> { +class LIsObjectAndBranch: public LControlInstruction<1, 1> { public: LIsObjectAndBranch(LOperand* value, LOperand* temp) { inputs_[0] = value; @@ -703,6 +751,31 @@ class LIsSmiAndBranch: public LControlInstruction<1, 0> { }; +class LIsUndetectable: public LTemplateInstruction<1, 1, 0> { + public: + explicit LIsUndetectable(LOperand* value) { + inputs_[0] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(IsUndetectable, "is-undetectable") + DECLARE_HYDROGEN_ACCESSOR(IsUndetectable) +}; + + +class LIsUndetectableAndBranch: public LControlInstruction<1, 1> { + public: + explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) { + inputs_[0] = value; + temps_[0] = temp; + } + + DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch, + "is-undetectable-and-branch") + + virtual void PrintDataTo(StringStream* stream); +}; + + class LHasInstanceType: public LTemplateInstruction<1, 1, 0> { public: explicit LHasInstanceType(LOperand* value) { @@ -728,25 +801,25 @@ class LHasInstanceTypeAndBranch: public LControlInstruction<1, 0> { }; -class LHasCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { +class LGetCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { public: - explicit LHasCachedArrayIndex(LOperand* value) { + explicit LGetCachedArrayIndex(LOperand* value) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndex, "has-cached-array-index") - DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndex) + DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index") + DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex) }; -class LGetCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { +class LHasCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { public: - explicit LGetCachedArrayIndex(LOperand* value) { + explicit LHasCachedArrayIndex(LOperand* value) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index") - DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex) + DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndex, "has-cached-array-index") + DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndex) }; @@ -804,20 +877,6 @@ class LCmpT: public LTemplateInstruction<1, 2, 0> { }; -class LCmpTAndBranch: public LControlInstruction<2, 0> { - public: - LCmpTAndBranch(LOperand* left, LOperand* right) { - inputs_[0] = left; - inputs_[1] = right; - } - - DECLARE_CONCRETE_INSTRUCTION(CmpTAndBranch, "cmp-t-and-branch") - DECLARE_HYDROGEN_ACCESSOR(Compare) - - Token::Value op() const { return hydrogen()->token(); } -}; - - class LInstanceOf: public LTemplateInstruction<1, 2, 0> { public: LInstanceOf(LOperand* left, LOperand* right) { @@ -829,17 +888,6 @@ class LInstanceOf: public LTemplateInstruction<1, 2, 0> { }; -class LInstanceOfAndBranch: public LControlInstruction<2, 0> { - public: - LInstanceOfAndBranch(LOperand* left, LOperand* right) { - inputs_[0] = left; - inputs_[1] = right; - } - - DECLARE_CONCRETE_INSTRUCTION(InstanceOfAndBranch, "instance-of-and-branch") -}; - - class LInstanceOfKnownGlobal: public LTemplateInstruction<1, 1, 1> { public: LInstanceOfKnownGlobal(LOperand* value, LOperand* temp) { @@ -991,14 +1039,14 @@ class LJSArrayLength: public LTemplateInstruction<1, 1, 0> { }; -class LPixelArrayLength: public LTemplateInstruction<1, 1, 0> { +class LExternalArrayLength: public LTemplateInstruction<1, 1, 0> { public: - explicit LPixelArrayLength(LOperand* value) { + explicit LExternalArrayLength(LOperand* value) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(PixelArrayLength, "pixel-array-length") - DECLARE_HYDROGEN_ACCESSOR(PixelArrayLength) + DECLARE_CONCRETE_INSTRUCTION(ExternalArrayLength, "external-array-length") + DECLARE_HYDROGEN_ACCESSOR(ExternalArrayLength) }; @@ -1013,6 +1061,17 @@ class LFixedArrayLength: public LTemplateInstruction<1, 1, 0> { }; +class LElementsKind: public LTemplateInstruction<1, 1, 0> { + public: + explicit LElementsKind(LOperand* value) { + inputs_[0] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(ElementsKind, "elements-kind") + DECLARE_HYDROGEN_ACCESSOR(ElementsKind) +}; + + class LValueOf: public LTemplateInstruction<1, 1, 1> { public: LValueOf(LOperand* value, LOperand* temp) { @@ -1079,6 +1138,7 @@ class LArithmeticD: public LTemplateInstruction<1, 2, 0> { Token::Value op() const { return op_; } + virtual Opcode opcode() const { return LInstruction::kArithmeticD; } virtual void CompileToNative(LCodeGen* generator); virtual const char* Mnemonic() const; @@ -1095,6 +1155,7 @@ class LArithmeticT: public LTemplateInstruction<1, 2, 0> { inputs_[1] = right; } + virtual Opcode opcode() const { return LInstruction::kArithmeticT; } virtual void CompileToNative(LCodeGen* generator); virtual const char* Mnemonic() const; @@ -1126,6 +1187,19 @@ class LLoadNamedField: public LTemplateInstruction<1, 1, 0> { }; +class LLoadNamedFieldPolymorphic: public LTemplateInstruction<1, 1, 0> { + public: + explicit LLoadNamedFieldPolymorphic(LOperand* object) { + inputs_[0] = object; + } + + DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field-polymorphic") + DECLARE_HYDROGEN_ACCESSOR(LoadNamedFieldPolymorphic) + + LOperand* object() { return inputs_[0]; } +}; + + class LLoadNamedGeneric: public LTemplateInstruction<1, 1, 0> { public: explicit LLoadNamedGeneric(LOperand* object) { @@ -1163,14 +1237,14 @@ class LLoadElements: public LTemplateInstruction<1, 1, 0> { }; -class LLoadPixelArrayExternalPointer: public LTemplateInstruction<1, 1, 0> { +class LLoadExternalArrayPointer: public LTemplateInstruction<1, 1, 0> { public: - explicit LLoadPixelArrayExternalPointer(LOperand* object) { + explicit LLoadExternalArrayPointer(LOperand* object) { inputs_[0] = object; } - DECLARE_CONCRETE_INSTRUCTION(LoadPixelArrayExternalPointer, - "load-pixel-array-external-pointer") + DECLARE_CONCRETE_INSTRUCTION(LoadExternalArrayPointer, + "load-external-array-pointer") }; @@ -1189,19 +1263,23 @@ class LLoadKeyedFastElement: public LTemplateInstruction<1, 2, 0> { }; -class LLoadPixelArrayElement: public LTemplateInstruction<1, 2, 0> { +class LLoadKeyedSpecializedArrayElement: public LTemplateInstruction<1, 2, 0> { public: - LLoadPixelArrayElement(LOperand* external_pointer, LOperand* key) { + LLoadKeyedSpecializedArrayElement(LOperand* external_pointer, + LOperand* key) { inputs_[0] = external_pointer; inputs_[1] = key; } - DECLARE_CONCRETE_INSTRUCTION(LoadPixelArrayElement, - "load-pixel-array-element") - DECLARE_HYDROGEN_ACCESSOR(LoadPixelArrayElement) + DECLARE_CONCRETE_INSTRUCTION(LoadKeyedSpecializedArrayElement, + "load-keyed-specialized-array-element") + DECLARE_HYDROGEN_ACCESSOR(LoadKeyedSpecializedArrayElement) LOperand* external_pointer() { return inputs_[0]; } LOperand* key() { return inputs_[1]; } + JSObject::ElementsKind elements_kind() const { + return hydrogen()->elements_kind(); + } }; @@ -1219,22 +1297,55 @@ class LLoadKeyedGeneric: public LTemplateInstruction<1, 2, 0> { }; -class LLoadGlobal: public LTemplateInstruction<1, 0, 0> { +class LLoadGlobalCell: public LTemplateInstruction<1, 0, 0> { public: - DECLARE_CONCRETE_INSTRUCTION(LoadGlobal, "load-global") - DECLARE_HYDROGEN_ACCESSOR(LoadGlobal) + DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell, "load-global-cell") + DECLARE_HYDROGEN_ACCESSOR(LoadGlobalCell) }; -class LStoreGlobal: public LTemplateInstruction<0, 1, 1> { +class LLoadGlobalGeneric: public LTemplateInstruction<1, 1, 0> { public: - LStoreGlobal(LOperand* value, LOperand* temp) { + explicit LLoadGlobalGeneric(LOperand* global_object) { + inputs_[0] = global_object; + } + + DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic") + DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric) + + LOperand* global_object() { return inputs_[0]; } + Handle<Object> name() const { return hydrogen()->name(); } + bool for_typeof() const { return hydrogen()->for_typeof(); } +}; + + +class LStoreGlobalCell: public LTemplateInstruction<0, 1, 1> { + public: + LStoreGlobalCell(LOperand* value, LOperand* temp) { inputs_[0] = value; temps_[0] = temp; } - DECLARE_CONCRETE_INSTRUCTION(StoreGlobal, "store-global") - DECLARE_HYDROGEN_ACCESSOR(StoreGlobal) + DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell, "store-global-cell") + DECLARE_HYDROGEN_ACCESSOR(StoreGlobalCell) +}; + + +class LStoreGlobalGeneric: public LTemplateInstruction<0, 2, 0> { + public: + explicit LStoreGlobalGeneric(LOperand* global_object, + LOperand* value) { + inputs_[0] = global_object; + inputs_[1] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(StoreGlobalGeneric, "store-global-generic") + DECLARE_HYDROGEN_ACCESSOR(StoreGlobalGeneric) + + LOperand* global_object() { return InputAt(0); } + Handle<Object> name() const { return hydrogen()->name(); } + LOperand* value() { return InputAt(1); } + bool strict_mode() { return hydrogen()->strict_mode(); } }; @@ -1283,6 +1394,11 @@ class LPushArgument: public LTemplateInstruction<0, 1, 0> { }; +class LThisFunction: public LTemplateInstruction<1, 0, 0> { + DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function") +}; + + class LContext: public LTemplateInstruction<1, 0, 0> { public: DECLARE_CONCRETE_INSTRUCTION(Context, "context") @@ -1337,6 +1453,23 @@ class LCallConstantFunction: public LTemplateInstruction<1, 0, 0> { }; +class LInvokeFunction: public LTemplateInstruction<1, 1, 0> { + public: + explicit LInvokeFunction(LOperand* function) { + inputs_[0] = function; + } + + DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function") + DECLARE_HYDROGEN_ACCESSOR(InvokeFunction) + + LOperand* function() { return inputs_[0]; } + + virtual void PrintDataTo(StringStream* stream); + + int arity() const { return hydrogen()->argument_count() - 1; } +}; + + class LCallKeyed: public LTemplateInstruction<1, 1, 0> { public: explicit LCallKeyed(LOperand* key) { @@ -1418,7 +1551,7 @@ class LCallRuntime: public LTemplateInstruction<1, 0, 0> { DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime") DECLARE_HYDROGEN_ACCESSOR(CallRuntime) - Runtime::Function* function() const { return hydrogen()->function(); } + const Runtime::Function* function() const { return hydrogen()->function(); } int arity() const { return hydrogen()->argument_count(); } }; @@ -1456,30 +1589,36 @@ class LNumberTagD: public LTemplateInstruction<1, 1, 2> { // Sometimes truncating conversion from a tagged value to an int32. -class LDoubleToI: public LTemplateInstruction<1, 1, 1> { +class LDoubleToI: public LTemplateInstruction<1, 1, 2> { public: - explicit LDoubleToI(LOperand* value, LOperand* temp1) { + LDoubleToI(LOperand* value, LOperand* temp1, LOperand* temp2) { inputs_[0] = value; temps_[0] = temp1; + temps_[1] = temp2; } DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i") - DECLARE_HYDROGEN_ACCESSOR(Change) + DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) bool truncating() { return hydrogen()->CanTruncateToInt32(); } }; // Truncating conversion from a tagged value to an int32. -class LTaggedToI: public LTemplateInstruction<1, 1, 1> { +class LTaggedToI: public LTemplateInstruction<1, 1, 3> { public: - LTaggedToI(LOperand* value, LOperand* temp) { + LTaggedToI(LOperand* value, + LOperand* temp1, + LOperand* temp2, + LOperand* temp3) { inputs_[0] = value; - temps_[0] = temp; + temps_[0] = temp1; + temps_[1] = temp2; + temps_[2] = temp3; } DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i") - DECLARE_HYDROGEN_ACCESSOR(Change) + DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) bool truncating() { return hydrogen()->CanTruncateToInt32(); } }; @@ -1502,6 +1641,7 @@ class LNumberUntagD: public LTemplateInstruction<1, 1, 0> { } DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag") + DECLARE_HYDROGEN_ACCESSOR(Change) }; @@ -1559,6 +1699,7 @@ class LStoreNamedGeneric: public LTemplateInstruction<0, 2, 0> { LOperand* object() { return inputs_[0]; } LOperand* value() { return inputs_[1]; } Handle<Object> name() const { return hydrogen()->name(); } + bool strict_mode() { return hydrogen()->strict_mode(); } }; @@ -1591,15 +1732,55 @@ class LStoreKeyedGeneric: public LTemplateInstruction<0, 3, 0> { } DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic") + DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric) virtual void PrintDataTo(StringStream* stream); LOperand* object() { return inputs_[0]; } LOperand* key() { return inputs_[1]; } LOperand* value() { return inputs_[2]; } + bool strict_mode() { return hydrogen()->strict_mode(); } +}; + +class LStoreKeyedSpecializedArrayElement: public LTemplateInstruction<0, 3, 0> { + public: + LStoreKeyedSpecializedArrayElement(LOperand* external_pointer, + LOperand* key, + LOperand* val) { + inputs_[0] = external_pointer; + inputs_[1] = key; + inputs_[2] = val; + } + + DECLARE_CONCRETE_INSTRUCTION(StoreKeyedSpecializedArrayElement, + "store-keyed-specialized-array-element") + DECLARE_HYDROGEN_ACCESSOR(StoreKeyedSpecializedArrayElement) + + LOperand* external_pointer() { return inputs_[0]; } + LOperand* key() { return inputs_[1]; } + LOperand* value() { return inputs_[2]; } + JSObject::ElementsKind elements_kind() const { + return hydrogen()->elements_kind(); + } }; +class LStringAdd: public LTemplateInstruction<1, 2, 0> { + public: + LStringAdd(LOperand* left, LOperand* right) { + inputs_[0] = left; + inputs_[1] = right; + } + + DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add") + DECLARE_HYDROGEN_ACCESSOR(StringAdd) + + LOperand* left() { return inputs_[0]; } + LOperand* right() { return inputs_[1]; } +}; + + + class LStringCharCodeAt: public LTemplateInstruction<1, 2, 0> { public: LStringCharCodeAt(LOperand* string, LOperand* index) { @@ -1615,6 +1796,19 @@ class LStringCharCodeAt: public LTemplateInstruction<1, 2, 0> { }; +class LStringCharFromCode: public LTemplateInstruction<1, 1, 0> { + public: + explicit LStringCharFromCode(LOperand* char_code) { + inputs_[0] = char_code; + } + + DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code") + DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode) + + LOperand* char_code() { return inputs_[0]; } +}; + + class LStringLength: public LTemplateInstruction<1, 1, 0> { public: explicit LStringLength(LOperand* string) { @@ -1678,20 +1872,59 @@ class LCheckPrototypeMaps: public LTemplateInstruction<0, 0, 2> { class LCheckSmi: public LTemplateInstruction<0, 1, 0> { public: - LCheckSmi(LOperand* value, Condition condition) - : condition_(condition) { + explicit LCheckSmi(LOperand* value) { inputs_[0] = value; } - Condition condition() const { return condition_; } + DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi") +}; - virtual void CompileToNative(LCodeGen* generator); - virtual const char* Mnemonic() const { - return (condition_ == eq) ? "check-non-smi" : "check-smi"; + +class LCheckNonSmi: public LTemplateInstruction<0, 1, 0> { + public: + explicit LCheckNonSmi(LOperand* value) { + inputs_[0] = value; } - private: - Condition condition_; + DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi") +}; + + +class LClampDToUint8: public LTemplateInstruction<1, 1, 1> { + public: + LClampDToUint8(LOperand* value, LOperand* temp) { + inputs_[0] = value; + temps_[0] = temp; + } + + LOperand* unclamped() { return inputs_[0]; } + + DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8") +}; + + +class LClampIToUint8: public LTemplateInstruction<1, 1, 0> { + public: + explicit LClampIToUint8(LOperand* value) { + inputs_[0] = value; + } + + LOperand* unclamped() { return inputs_[0]; } + + DECLARE_CONCRETE_INSTRUCTION(ClampIToUint8, "clamp-i-to-uint8") +}; + + +class LClampTToUint8: public LTemplateInstruction<1, 1, 1> { + public: + LClampTToUint8(LOperand* value, LOperand* temp) { + inputs_[0] = value; + temps_[0] = temp; + } + + LOperand* unclamped() { return inputs_[0]; } + + DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8") }; @@ -1725,6 +1958,17 @@ class LFunctionLiteral: public LTemplateInstruction<1, 0, 0> { }; +class LToFastProperties: public LTemplateInstruction<1, 1, 0> { + public: + explicit LToFastProperties(LOperand* value) { + inputs_[0] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties") + DECLARE_HYDROGEN_ACCESSOR(ToFastProperties) +}; + + class LTypeof: public LTemplateInstruction<1, 1, 0> { public: explicit LTypeof(LOperand* value) { @@ -1823,13 +2067,33 @@ class LOsrEntry: public LTemplateInstruction<0, 0, 0> { class LStackCheck: public LTemplateInstruction<0, 0, 0> { public: DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check") + DECLARE_HYDROGEN_ACCESSOR(StackCheck) + + Label* done_label() { return &done_label_; } + + private: + Label done_label_; +}; + + +class LIn: public LTemplateInstruction<1, 2, 0> { + public: + LIn(LOperand* key, LOperand* object) { + inputs_[0] = key; + inputs_[1] = object; + } + + LOperand* key() { return inputs_[0]; } + LOperand* object() { return inputs_[1]; } + + DECLARE_CONCRETE_INSTRUCTION(In, "in") }; class LChunkBuilder; class LChunk: public ZoneObject { public: - explicit LChunk(HGraph* graph); + explicit LChunk(CompilationInfo* info, HGraph* graph); void AddInstruction(LInstruction* instruction, HBasicBlock* block); LConstantOperand* DefineConstantOperand(HConstant* constant); @@ -1842,6 +2106,7 @@ class LChunk: public ZoneObject { int ParameterAt(int index); int GetParameterStackSlot(int index) const; int spill_slot_count() const { return spill_slot_count_; } + CompilationInfo* info() const { return info_; } HGraph* graph() const { return graph_; } const ZoneList<LInstruction*>* instructions() const { return &instructions_; } void AddGapMove(int index, LOperand* from, LOperand* to); @@ -1878,6 +2143,7 @@ class LChunk: public ZoneObject { private: int spill_slot_count_; + CompilationInfo* info_; HGraph* const graph_; ZoneList<LInstruction*> instructions_; ZoneList<LPointerMap*> pointer_maps_; @@ -1887,8 +2153,9 @@ class LChunk: public ZoneObject { class LChunkBuilder BASE_EMBEDDED { public: - LChunkBuilder(HGraph* graph, LAllocator* allocator) + LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator) : chunk_(NULL), + info_(info), graph_(graph), status_(UNUSED), current_instruction_(NULL), @@ -1917,6 +2184,7 @@ class LChunkBuilder BASE_EMBEDDED { }; LChunk* chunk() const { return chunk_; } + CompilationInfo* info() const { return info_; } HGraph* graph() const { return graph_; } bool is_unused() const { return status_ == UNUSED; } @@ -2023,6 +2291,7 @@ class LChunkBuilder BASE_EMBEDDED { HArithmeticBinaryOperation* instr); LChunk* chunk_; + CompilationInfo* info_; HGraph* const graph_; Status status_; HInstruction* current_instruction_; @@ -2038,7 +2307,6 @@ class LChunkBuilder BASE_EMBEDDED { }; #undef DECLARE_HYDROGEN_ACCESSOR -#undef DECLARE_INSTRUCTION #undef DECLARE_CONCRETE_INSTRUCTION } } // namespace v8::internal |