diff options
Diffstat (limited to 'deps/v8/src/x64/lithium-x64.h')
| -rw-r--r-- | deps/v8/src/x64/lithium-x64.h | 541 |
1 files changed, 394 insertions, 147 deletions
diff --git a/deps/v8/src/x64/lithium-x64.h b/deps/v8/src/x64/lithium-x64.h index fed5b8cb8..d500dfd87 100644 --- a/deps/v8/src/x64/lithium-x64.h +++ b/deps/v8/src/x64/lithium-x64.h @@ -32,6 +32,7 @@ #include "lithium-allocator.h" #include "lithium.h" #include "safepoint-table.h" +#include "utils.h" namespace v8 { namespace internal { @@ -70,15 +71,22 @@ class LCodeGen; V(CheckFunction) \ V(CheckInstanceType) \ V(CheckMap) \ + V(CheckNonSmi) \ 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) \ @@ -87,41 +95,49 @@ class LCodeGen; V(Deoptimize) \ V(DivI) \ V(DoubleToI) \ + V(ElementsKind) \ + V(ExternalArrayLength) \ + V(FixedArrayLength) \ V(FunctionLiteral) \ - V(Gap) \ + V(GetCachedArrayIndex) \ V(GlobalObject) \ V(GlobalReceiver) \ V(Goto) \ - V(FixedArrayLength) \ + V(HasCachedArrayIndex) \ + 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(HasInstanceType) \ - V(HasInstanceTypeAndBranch) \ - V(HasCachedArrayIndex) \ - V(HasCachedArrayIndexAndBranch) \ - V(ClassOfTest) \ - V(ClassOfTestAndBranch) \ V(Label) \ V(LazyBailout) \ V(LoadContextSlot) \ V(LoadElements) \ - V(LoadGlobal) \ + V(LoadExternalArrayPointer) \ + V(LoadFunctionPrototype) \ + V(LoadGlobalCell) \ + V(LoadGlobalGeneric) \ V(LoadKeyedFastElement) \ V(LoadKeyedGeneric) \ + V(LoadKeyedSpecializedArrayElement) \ V(LoadNamedField) \ + V(LoadNamedFieldPolymorphic) \ V(LoadNamedGeneric) \ - V(LoadFunctionPrototype) \ - V(LoadPixelArrayElement) \ - V(LoadPixelArrayExternalPointer) \ V(ModI) \ V(MulI) \ V(NumberTagD) \ @@ -131,7 +147,6 @@ class LCodeGen; V(OsrEntry) \ V(OuterContext) \ V(Parameter) \ - V(PixelArrayLength) \ V(Power) \ V(PushArgument) \ V(RegExpLiteral) \ @@ -141,41 +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(StorePixelArrayElement) \ + 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()); \ @@ -198,10 +212,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) { } @@ -259,37 +288,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. @@ -312,9 +310,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_; }; @@ -328,8 +326,13 @@ class LGap: public LTemplateInstruction<0, 0, 0> { parallel_moves_[AFTER] = NULL; } - DECLARE_CONCRETE_INSTRUCTION(Gap, "gap") + // 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; @@ -359,21 +362,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_; }; @@ -447,7 +455,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_; } @@ -608,26 +615,49 @@ class LUnaryMathOperation: public LTemplateInstruction<1, 1, 0> { }; -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) }; @@ -705,6 +735,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) { @@ -730,6 +785,17 @@ class LHasInstanceTypeAndBranch: public LControlInstruction<1, 0> { }; +class LGetCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { + public: + explicit LGetCachedArrayIndex(LOperand* value) { + inputs_[0] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index") + DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex) +}; + + class LHasCachedArrayIndex: public LTemplateInstruction<1, 1, 0> { public: explicit LHasCachedArrayIndex(LOperand* value) { @@ -796,17 +862,17 @@ class LCmpT: public LTemplateInstruction<1, 2, 0> { }; -class LCmpTAndBranch: public LControlInstruction<2, 0> { +class LIn: public LTemplateInstruction<1, 2, 0> { public: - LCmpTAndBranch(LOperand* left, LOperand* right) { - inputs_[0] = left; - inputs_[1] = right; + LIn(LOperand* key, LOperand* object) { + inputs_[0] = key; + inputs_[1] = object; } - DECLARE_CONCRETE_INSTRUCTION(CmpTAndBranch, "cmp-t-and-branch") - DECLARE_HYDROGEN_ACCESSOR(Compare) + LOperand* key() { return inputs_[0]; } + LOperand* object() { return inputs_[1]; } - Token::Value op() const { return hydrogen()->token(); } + DECLARE_CONCRETE_INSTRUCTION(In, "in") }; @@ -821,21 +887,11 @@ 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, 0> { +class LInstanceOfKnownGlobal: public LTemplateInstruction<1, 1, 1> { public: - explicit LInstanceOfKnownGlobal(LOperand* value) { + LInstanceOfKnownGlobal(LOperand* value, LOperand* temp) { inputs_[0] = value; + temps_[0] = temp; } DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal, @@ -984,14 +1040,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) }; @@ -1006,6 +1062,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, 0> { public: explicit LValueOf(LOperand* value) { @@ -1071,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; @@ -1087,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; @@ -1118,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) { @@ -1155,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") }; @@ -1181,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(); + } }; @@ -1211,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: - explicit 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: + explicit 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(); } }; @@ -1246,11 +1365,12 @@ class LLoadContextSlot: public LTemplateInstruction<1, 1, 0> { }; -class LStoreContextSlot: public LTemplateInstruction<0, 2, 0> { +class LStoreContextSlot: public LTemplateInstruction<0, 2, 1> { public: - LStoreContextSlot(LOperand* context, LOperand* value) { + LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) { inputs_[0] = context; inputs_[1] = value; + temps_[0] = temp; } DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store-context-slot") @@ -1275,6 +1395,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") @@ -1299,9 +1424,15 @@ class LGlobalObject: public LTemplateInstruction<1, 0, 0> { }; -class LGlobalReceiver: public LTemplateInstruction<1, 0, 0> { +class LGlobalReceiver: public LTemplateInstruction<1, 1, 0> { public: + explicit LGlobalReceiver(LOperand* global_object) { + inputs_[0] = global_object; + } + DECLARE_CONCRETE_INSTRUCTION(GlobalReceiver, "global-receiver") + + LOperand* global() { return InputAt(0); } }; @@ -1317,6 +1448,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) { @@ -1401,7 +1549,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(); } }; @@ -1445,7 +1593,7 @@ class LDoubleToI: public LTemplateInstruction<1, 1, 0> { } DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i") - DECLARE_HYDROGEN_ACCESSOR(Change) + DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) bool truncating() { return hydrogen()->CanTruncateToInt32(); } }; @@ -1460,7 +1608,7 @@ class LTaggedToI: public LTemplateInstruction<1, 1, 1> { } DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i") - DECLARE_HYDROGEN_ACCESSOR(Change) + DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) bool truncating() { return hydrogen()->CanTruncateToInt32(); } }; @@ -1483,6 +1631,7 @@ class LNumberUntagD: public LTemplateInstruction<1, 1, 0> { } DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag") + DECLARE_HYDROGEN_ACCESSOR(Change); }; @@ -1541,6 +1690,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(); } }; @@ -1564,23 +1714,26 @@ class LStoreKeyedFastElement: public LTemplateInstruction<0, 3, 0> { }; -class LStorePixelArrayElement: public LTemplateInstruction<0, 3, 0> { +class LStoreKeyedSpecializedArrayElement: public LTemplateInstruction<0, 3, 0> { public: - LStorePixelArrayElement(LOperand* external_pointer, - LOperand* key, - LOperand* val) { + LStoreKeyedSpecializedArrayElement(LOperand* external_pointer, + LOperand* key, + LOperand* val) { inputs_[0] = external_pointer; inputs_[1] = key; inputs_[2] = val; } - DECLARE_CONCRETE_INSTRUCTION(StorePixelArrayElement, - "store-pixel-array-element") - DECLARE_HYDROGEN_ACCESSOR(StorePixelArrayElement) + 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(); + } }; @@ -1593,12 +1746,29 @@ 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 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]; } }; @@ -1617,6 +1787,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) { @@ -1679,20 +1862,62 @@ class LCheckPrototypeMaps: public LTemplateInstruction<0, 0, 1> { 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_ == zero) ? "check-non-smi" : "check-smi"; + +class LClampDToUint8: public LTemplateInstruction<1, 1, 1> { + public: + LClampDToUint8(LOperand* value, LOperand* temp) { + inputs_[0] = value; + temps_[0] = temp; } - private: - Condition condition_; + 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, 2> { + public: + LClampTToUint8(LOperand* value, + LOperand* temp, + LOperand* temp2) { + inputs_[0] = value; + temps_[0] = temp; + temps_[1] = temp2; + } + + LOperand* unclamped() { return inputs_[0]; } + + DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8") +}; + + +class LCheckNonSmi: public LTemplateInstruction<0, 1, 0> { + public: + explicit LCheckNonSmi(LOperand* value) { + inputs_[0] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi") }; @@ -1726,6 +1951,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) { @@ -1824,14 +2060,21 @@ 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 LChunkBuilder; class LChunk: public ZoneObject { public: - explicit LChunk(HGraph* graph) + explicit LChunk(CompilationInfo* info, HGraph* graph) : spill_slot_count_(0), + info_(info), graph_(graph), instructions_(32), pointer_maps_(8), @@ -1848,6 +2091,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); @@ -1884,6 +2128,7 @@ class LChunk: public ZoneObject { private: int spill_slot_count_; + CompilationInfo* info_; HGraph* const graph_; ZoneList<LInstruction*> instructions_; ZoneList<LPointerMap*> pointer_maps_; @@ -1893,8 +2138,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), @@ -1923,6 +2169,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; } @@ -2029,6 +2276,7 @@ class LChunkBuilder BASE_EMBEDDED { HArithmeticBinaryOperation* instr); LChunk* chunk_; + CompilationInfo* info_; HGraph* const graph_; Status status_; HInstruction* current_instruction_; @@ -2044,7 +2292,6 @@ class LChunkBuilder BASE_EMBEDDED { }; #undef DECLARE_HYDROGEN_ACCESSOR -#undef DECLARE_INSTRUCTION #undef DECLARE_CONCRETE_INSTRUCTION } } // namespace v8::int |