diff options
Diffstat (limited to 'deps/v8/src/ia32/lithium-ia32.h')
| -rw-r--r-- | deps/v8/src/ia32/lithium-ia32.h | 623 |
1 files changed, 274 insertions, 349 deletions
diff --git a/deps/v8/src/ia32/lithium-ia32.h b/deps/v8/src/ia32/lithium-ia32.h index 5f4dd2520..ad0b0ca05 100644 --- a/deps/v8/src/ia32/lithium-ia32.h +++ b/deps/v8/src/ia32/lithium-ia32.h @@ -32,7 +32,6 @@ #include "lithium-allocator.h" #include "lithium.h" #include "safepoint-table.h" -#include "utils.h" namespace v8 { namespace internal { @@ -40,6 +39,12 @@ namespace internal { // Forward declarations. class LCodeGen; +#define LITHIUM_ALL_INSTRUCTION_LIST(V) \ + V(ControlInstruction) \ + V(Call) \ + LITHIUM_CONCRETE_INSTRUCTION_LIST(V) + + #define LITHIUM_CONCRETE_INSTRUCTION_LIST(V) \ V(AccessArgumentsAt) \ V(AddI) \ @@ -65,18 +70,17 @@ 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(CmpID) \ V(CmpIDAndBranch) \ - V(CmpObjectEqAndBranch) \ + V(CmpJSObjectEq) \ + V(CmpJSObjectEqAndBranch) \ V(CmpMapAndBranch) \ V(CmpT) \ - V(CmpConstantEqAndBranch) \ + V(CmpTAndBranch) \ V(ConstantD) \ V(ConstantI) \ V(ConstantT) \ @@ -85,42 +89,41 @@ class LCodeGen; V(Deoptimize) \ V(DivI) \ V(DoubleToI) \ - V(ElementsKind) \ - V(ExternalArrayLength) \ V(FixedArrayLength) \ V(FunctionLiteral) \ - V(GetCachedArrayIndex) \ + V(Gap) \ V(GlobalObject) \ V(GlobalReceiver) \ V(Goto) \ + V(HasCachedArrayIndex) \ V(HasCachedArrayIndexAndBranch) \ + V(HasInstanceType) \ V(HasInstanceTypeAndBranch) \ - V(In) \ V(InstanceOf) \ + V(InstanceOfAndBranch) \ V(InstanceOfKnownGlobal) \ - V(InstructionGap) \ V(Integer32ToDouble) \ - V(InvokeFunction) \ - V(IsConstructCallAndBranch) \ + V(IsNull) \ V(IsNullAndBranch) \ + V(IsObject) \ V(IsObjectAndBranch) \ + V(IsSmi) \ V(IsSmiAndBranch) \ - V(IsUndetectableAndBranch) \ + V(IsConstructCall) \ + V(IsConstructCallAndBranch) \ V(JSArrayLength) \ V(Label) \ V(LazyBailout) \ V(LoadContextSlot) \ V(LoadElements) \ - V(LoadExternalArrayPointer) \ V(LoadFunctionPrototype) \ - V(LoadGlobalCell) \ - V(LoadGlobalGeneric) \ + V(LoadGlobal) \ V(LoadKeyedFastElement) \ V(LoadKeyedGeneric) \ - V(LoadKeyedSpecializedArrayElement) \ V(LoadNamedField) \ - V(LoadNamedFieldPolymorphic) \ V(LoadNamedGeneric) \ + V(LoadPixelArrayElement) \ + V(LoadPixelArrayExternalPointer) \ V(ModI) \ V(MulI) \ V(NumberTagD) \ @@ -130,6 +133,7 @@ class LCodeGen; V(OsrEntry) \ V(OuterContext) \ V(Parameter) \ + V(PixelArrayLength) \ V(Power) \ V(PushArgument) \ V(RegExpLiteral) \ @@ -139,39 +143,39 @@ class LCodeGen; V(SmiUntag) \ V(StackCheck) \ V(StoreContextSlot) \ - V(StoreGlobalCell) \ - V(StoreGlobalGeneric) \ + V(StoreGlobal) \ V(StoreKeyedFastElement) \ V(StoreKeyedGeneric) \ - V(StoreKeyedSpecializedArrayElement) \ V(StoreNamedField) \ V(StoreNamedGeneric) \ - V(StringAdd) \ + V(StorePixelArrayElement) \ V(StringCharCodeAt) \ - V(StringCharFromCode) \ V(StringLength) \ V(SubI) \ V(TaggedToI) \ - V(ThisFunction) \ V(Throw) \ - V(ToFastProperties) \ V(Typeof) \ + V(TypeofIs) \ V(TypeofIsAndBranch) \ V(UnaryMathOperation) \ V(UnknownOSRValue) \ V(ValueOf) -#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_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 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()); \ @@ -193,27 +197,13 @@ class LInstruction: public ZoneObject { virtual void PrintDataTo(StringStream* stream) = 0; virtual void PrintOutputOperandTo(StringStream* stream) = 0; - 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; } + // Declare virtual type testers. +#define DECLARE_DO(type) virtual bool Is##type() const { return false; } + LITHIUM_ALL_INSTRUCTION_LIST(DECLARE_DO) +#undef DECLARE_DO virtual bool IsControl() const { return false; } + virtual void SetBranchTargets(int true_block_id, int false_block_id) { } void set_environment(LEnvironment* env) { environment_ = env; } LEnvironment* environment() const { return environment_; } @@ -269,6 +259,37 @@ 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. @@ -291,28 +312,24 @@ class LTemplateInstruction: public LInstruction { virtual void PrintOutputOperandTo(StringStream* stream); protected: - EmbeddedContainer<LOperand*, R> results_; - EmbeddedContainer<LOperand*, I> inputs_; - EmbeddedContainer<LOperand*, T> temps_; + OperandContainer<LOperand*, R> results_; + OperandContainer<LOperand*, I> inputs_; + OperandContainer<LOperand*, T> temps_; }; class LGap: public LTemplateInstruction<0, 0, 0> { public: - explicit LGap(HBasicBlock* block) : block_(block) { + explicit LGap(HBasicBlock* block) + : block_(block) { parallel_moves_[BEFORE] = NULL; parallel_moves_[START] = NULL; parallel_moves_[END] = NULL; parallel_moves_[AFTER] = NULL; } - // Can't use the DECLARE-macro here because of sub-classes. - virtual bool IsGap() const { return true; } + DECLARE_CONCRETE_INSTRUCTION(Gap, "gap") virtual void PrintDataTo(StringStream* stream); - static LGap* cast(LInstruction* instr) { - ASSERT(instr->IsGap()); - return reinterpret_cast<LGap*>(instr); - } bool IsRedundant() const; @@ -342,26 +359,21 @@ 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: - explicit LGoto(int block_id) : block_id_(block_id) { } + LGoto(int block_id, bool include_stack_check = false) + : block_id_(block_id), include_stack_check_(include_stack_check) { } 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_; }; @@ -441,17 +453,19 @@ 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 SuccessorCount() { return hydrogen()->SuccessorCount(); } - HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); } - int true_block_id() { return hydrogen()->SuccessorAt(0)->block_id(); } - int false_block_id() { return hydrogen()->SuccessorAt(1)->block_id(); } + int true_block_id() const { return true_block_id_; } + int false_block_id() const { return false_block_id_; } + void SetBranchTargets(int true_block_id, int false_block_id) { + true_block_id_ = true_block_id; + false_block_id_ = false_block_id; + } private: - HControlInstruction* hydrogen() { - return HControlInstruction::cast(this->hydrogen_value()); - } + int true_block_id_; + int false_block_id_; }; @@ -553,6 +567,23 @@ class LMulI: public LTemplateInstruction<1, 2, 1> { }; +class LCmpID: public LTemplateInstruction<1, 2, 0> { + public: + LCmpID(LOperand* left, LOperand* right) { + inputs_[0] = left; + inputs_[1] = right; + } + + DECLARE_CONCRETE_INSTRUCTION(CmpID, "cmp-id") + DECLARE_HYDROGEN_ACCESSOR(Compare) + + Token::Value op() const { return hydrogen()->token(); } + bool is_double() const { + return hydrogen()->GetInputRepresentation().IsDouble(); + } +}; + + class LCmpIDAndBranch: public LControlInstruction<2, 0> { public: LCmpIDAndBranch(LOperand* left, LOperand* right) { @@ -561,7 +592,7 @@ class LCmpIDAndBranch: public LControlInstruction<2, 0> { } DECLARE_CONCRETE_INSTRUCTION(CmpIDAndBranch, "cmp-id-and-branch") - DECLARE_HYDROGEN_ACCESSOR(CompareIDAndBranch) + DECLARE_HYDROGEN_ACCESSOR(Compare) Token::Value op() const { return hydrogen()->token(); } bool is_double() const { @@ -586,27 +617,39 @@ class LUnaryMathOperation: public LTemplateInstruction<1, 1, 0> { }; -class LCmpObjectEqAndBranch: public LControlInstruction<2, 0> { +class LCmpJSObjectEq: public LTemplateInstruction<1, 2, 0> { public: - LCmpObjectEqAndBranch(LOperand* left, LOperand* right) { + LCmpJSObjectEq(LOperand* left, LOperand* right) { inputs_[0] = left; inputs_[1] = right; } - DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, - "cmp-object-eq-and-branch") + DECLARE_CONCRETE_INSTRUCTION(CmpJSObjectEq, "cmp-jsobject-eq") }; -class LCmpConstantEqAndBranch: public LControlInstruction<1, 0> { +class LCmpJSObjectEqAndBranch: public LControlInstruction<2, 0> { public: - explicit LCmpConstantEqAndBranch(LOperand* left) { + LCmpJSObjectEqAndBranch(LOperand* left, LOperand* right) { inputs_[0] = left; + inputs_[1] = right; + } + + DECLARE_CONCRETE_INSTRUCTION(CmpJSObjectEqAndBranch, + "cmp-jsobject-eq-and-branch") +}; + + +class LIsNull: public LTemplateInstruction<1, 1, 0> { + public: + explicit LIsNull(LOperand* value) { + inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(CmpConstantEqAndBranch, - "cmp-constant-eq-and-branch") - DECLARE_HYDROGEN_ACCESSOR(CompareConstantEqAndBranch) + DECLARE_CONCRETE_INSTRUCTION(IsNull, "is-null") + DECLARE_HYDROGEN_ACCESSOR(IsNull) + + bool is_strict() const { return hydrogen()->is_strict(); } }; @@ -618,7 +661,7 @@ class LIsNullAndBranch: public LControlInstruction<1, 1> { } DECLARE_CONCRETE_INSTRUCTION(IsNullAndBranch, "is-null-and-branch") - DECLARE_HYDROGEN_ACCESSOR(IsNullAndBranch) + DECLARE_HYDROGEN_ACCESSOR(IsNull) bool is_strict() const { return hydrogen()->is_strict(); } @@ -626,11 +669,23 @@ class LIsNullAndBranch: public LControlInstruction<1, 1> { }; -class LIsObjectAndBranch: public LControlInstruction<1, 1> { +class LIsObject: public LTemplateInstruction<1, 1, 1> { + public: + LIsObject(LOperand* value, LOperand* temp) { + inputs_[0] = value; + temps_[0] = temp; + } + + DECLARE_CONCRETE_INSTRUCTION(IsObject, "is-object") +}; + + +class LIsObjectAndBranch: public LControlInstruction<1, 2> { public: - LIsObjectAndBranch(LOperand* value, LOperand* temp) { + LIsObjectAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) { inputs_[0] = value; temps_[0] = temp; + temps_[1] = temp2; } DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch") @@ -639,6 +694,17 @@ class LIsObjectAndBranch: public LControlInstruction<1, 1> { }; +class LIsSmi: public LTemplateInstruction<1, 1, 0> { + public: + explicit LIsSmi(LOperand* value) { + inputs_[0] = value; + } + + DECLARE_CONCRETE_INSTRUCTION(IsSmi, "is-smi") + DECLARE_HYDROGEN_ACCESSOR(IsSmi) +}; + + class LIsSmiAndBranch: public LControlInstruction<1, 0> { public: explicit LIsSmiAndBranch(LOperand* value) { @@ -646,23 +712,19 @@ class LIsSmiAndBranch: public LControlInstruction<1, 0> { } DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch") - DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch) virtual void PrintDataTo(StringStream* stream); }; -class LIsUndetectableAndBranch: public LControlInstruction<1, 1> { +class LHasInstanceType: public LTemplateInstruction<1, 1, 0> { public: - explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) { + explicit LHasInstanceType(LOperand* value) { inputs_[0] = value; - temps_[0] = temp; } - DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch, - "is-undetectable-and-branch") - - virtual void PrintDataTo(StringStream* stream); + DECLARE_CONCRETE_INSTRUCTION(HasInstanceType, "has-instance-type") + DECLARE_HYDROGEN_ACCESSOR(HasInstanceType) }; @@ -675,20 +737,20 @@ class LHasInstanceTypeAndBranch: public LControlInstruction<1, 1> { DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch, "has-instance-type-and-branch") - DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch) + DECLARE_HYDROGEN_ACCESSOR(HasInstanceType) virtual void PrintDataTo(StringStream* stream); }; -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) }; @@ -704,6 +766,13 @@ class LHasCachedArrayIndexAndBranch: public LControlInstruction<1, 0> { }; +class LIsConstructCall: public LTemplateInstruction<1, 0, 0> { + public: + DECLARE_CONCRETE_INSTRUCTION(IsConstructCall, "is-construct-call") + DECLARE_HYDROGEN_ACCESSOR(IsConstructCall) +}; + + class LIsConstructCallAndBranch: public LControlInstruction<0, 1> { public: explicit LIsConstructCallAndBranch(LOperand* temp) { @@ -715,6 +784,20 @@ class LIsConstructCallAndBranch: public LControlInstruction<0, 1> { }; +class LClassOfTest: public LTemplateInstruction<1, 1, 1> { + public: + LClassOfTest(LOperand* value, LOperand* temp) { + inputs_[0] = value; + temps_[0] = temp; + } + + DECLARE_CONCRETE_INSTRUCTION(ClassOfTest, "class-of-test") + DECLARE_HYDROGEN_ACCESSOR(ClassOfTest) + + virtual void PrintDataTo(StringStream* stream); +}; + + class LClassOfTestAndBranch: public LControlInstruction<1, 2> { public: LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) { @@ -725,7 +808,7 @@ class LClassOfTestAndBranch: public LControlInstruction<1, 2> { DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch, "class-of-test-and-branch") - DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch) + DECLARE_HYDROGEN_ACCESSOR(ClassOfTest) virtual void PrintDataTo(StringStream* stream); }; @@ -739,7 +822,21 @@ class LCmpT: public LTemplateInstruction<1, 2, 0> { } DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t") - DECLARE_HYDROGEN_ACCESSOR(CompareGeneric) + DECLARE_HYDROGEN_ACCESSOR(Compare) + + Token::Value op() const { return hydrogen()->token(); } +}; + + +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(); } }; @@ -759,6 +856,20 @@ class LInstanceOf: public LTemplateInstruction<1, 3, 0> { }; +class LInstanceOfAndBranch: public LControlInstruction<3, 0> { + public: + LInstanceOfAndBranch(LOperand* context, LOperand* left, LOperand* right) { + inputs_[0] = context; + inputs_[1] = left; + inputs_[2] = right; + } + + DECLARE_CONCRETE_INSTRUCTION(InstanceOfAndBranch, "instance-of-and-branch") + + LOperand* context() { return inputs_[0]; } +}; + + class LInstanceOfKnownGlobal: public LTemplateInstruction<1, 1, 1> { public: LInstanceOfKnownGlobal(LOperand* value, LOperand* temp) { @@ -875,7 +986,7 @@ class LBranch: public LControlInstruction<1, 0> { } DECLARE_CONCRETE_INSTRUCTION(Branch, "branch") - DECLARE_HYDROGEN_ACCESSOR(Branch) + DECLARE_HYDROGEN_ACCESSOR(Value) virtual void PrintDataTo(StringStream* stream); }; @@ -913,14 +1024,14 @@ class LJSArrayLength: public LTemplateInstruction<1, 1, 0> { }; -class LExternalArrayLength: public LTemplateInstruction<1, 1, 0> { +class LPixelArrayLength: public LTemplateInstruction<1, 1, 0> { public: - explicit LExternalArrayLength(LOperand* value) { + explicit LPixelArrayLength(LOperand* value) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(ExternalArrayLength, "external-array-length") - DECLARE_HYDROGEN_ACCESSOR(ExternalArrayLength) + DECLARE_CONCRETE_INSTRUCTION(PixelArrayLength, "pixel-array-length") + DECLARE_HYDROGEN_ACCESSOR(PixelArrayLength) }; @@ -935,17 +1046,6 @@ 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) { @@ -1012,7 +1112,6 @@ 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; @@ -1029,7 +1128,6 @@ 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; @@ -1058,21 +1156,6 @@ class LLoadNamedField: public LTemplateInstruction<1, 1, 0> { DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field") DECLARE_HYDROGEN_ACCESSOR(LoadNamedField) - - LOperand* object() { return inputs_[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]; } }; @@ -1116,14 +1199,14 @@ class LLoadElements: public LTemplateInstruction<1, 1, 0> { }; -class LLoadExternalArrayPointer: public LTemplateInstruction<1, 1, 0> { +class LLoadPixelArrayExternalPointer: public LTemplateInstruction<1, 1, 0> { public: - explicit LLoadExternalArrayPointer(LOperand* object) { + explicit LLoadPixelArrayExternalPointer(LOperand* object) { inputs_[0] = object; } - DECLARE_CONCRETE_INSTRUCTION(LoadExternalArrayPointer, - "load-external-array-pointer") + DECLARE_CONCRETE_INSTRUCTION(LoadPixelArrayExternalPointer, + "load-pixel-array-external-pointer") }; @@ -1142,23 +1225,19 @@ class LLoadKeyedFastElement: public LTemplateInstruction<1, 2, 0> { }; -class LLoadKeyedSpecializedArrayElement: public LTemplateInstruction<1, 2, 0> { +class LLoadPixelArrayElement: public LTemplateInstruction<1, 2, 0> { public: - LLoadKeyedSpecializedArrayElement(LOperand* external_pointer, - LOperand* key) { + LLoadPixelArrayElement(LOperand* external_pointer, LOperand* key) { inputs_[0] = external_pointer; inputs_[1] = key; } - DECLARE_CONCRETE_INSTRUCTION(LoadKeyedSpecializedArrayElement, - "load-keyed-specialized-array-element") - DECLARE_HYDROGEN_ACCESSOR(LoadKeyedSpecializedArrayElement) + DECLARE_CONCRETE_INSTRUCTION(LoadPixelArrayElement, + "load-pixel-array-element") + DECLARE_HYDROGEN_ACCESSOR(LoadPixelArrayElement) LOperand* external_pointer() { return inputs_[0]; } LOperand* key() { return inputs_[1]; } - JSObject::ElementsKind elements_kind() const { - return hydrogen()->elements_kind(); - } }; @@ -1178,59 +1257,21 @@ class LLoadKeyedGeneric: public LTemplateInstruction<1, 3, 0> { }; -class LLoadGlobalCell: public LTemplateInstruction<1, 0, 0> { +class LLoadGlobal: public LTemplateInstruction<1, 0, 0> { public: - DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell, "load-global-cell") - DECLARE_HYDROGEN_ACCESSOR(LoadGlobalCell) -}; - - -class LLoadGlobalGeneric: public LTemplateInstruction<1, 2, 0> { - public: - LLoadGlobalGeneric(LOperand* context, LOperand* global_object) { - inputs_[0] = context; - inputs_[1] = global_object; - } - - DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic") - DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric) - - LOperand* context() { return inputs_[0]; } - LOperand* global_object() { return inputs_[1]; } - Handle<Object> name() const { return hydrogen()->name(); } - bool for_typeof() const { return hydrogen()->for_typeof(); } + DECLARE_CONCRETE_INSTRUCTION(LoadGlobal, "load-global") + DECLARE_HYDROGEN_ACCESSOR(LoadGlobal) }; -class LStoreGlobalCell: public LTemplateInstruction<0, 1, 0> { +class LStoreGlobal: public LTemplateInstruction<0, 1, 0> { public: - explicit LStoreGlobalCell(LOperand* value) { + explicit LStoreGlobal(LOperand* value) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell, "store-global-cell") - DECLARE_HYDROGEN_ACCESSOR(StoreGlobalCell) -}; - - -class LStoreGlobalGeneric: public LTemplateInstruction<0, 3, 0> { - public: - explicit LStoreGlobalGeneric(LOperand* context, - LOperand* global_object, - LOperand* value) { - inputs_[0] = context; - inputs_[1] = global_object; - inputs_[2] = value; - } - - DECLARE_CONCRETE_INSTRUCTION(StoreGlobalGeneric, "store-global-generic") - DECLARE_HYDROGEN_ACCESSOR(StoreGlobalGeneric) - - LOperand* context() { return InputAt(0); } - LOperand* global_object() { return InputAt(1); } - Handle<Object> name() const { return hydrogen()->name(); } - LOperand* value() { return InputAt(2); } - bool strict_mode() { return hydrogen()->strict_mode(); } + DECLARE_CONCRETE_INSTRUCTION(StoreGlobal, "store-global") + DECLARE_HYDROGEN_ACCESSOR(StoreGlobal) }; @@ -1280,11 +1321,6 @@ 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") @@ -1339,25 +1375,6 @@ class LCallConstantFunction: public LTemplateInstruction<1, 0, 0> { }; -class LInvokeFunction: public LTemplateInstruction<1, 2, 0> { - public: - LInvokeFunction(LOperand* context, LOperand* function) { - inputs_[0] = context; - inputs_[1] = function; - } - - DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function") - DECLARE_HYDROGEN_ACCESSOR(InvokeFunction) - - LOperand* context() { return inputs_[0]; } - LOperand* function() { return inputs_[1]; } - - virtual void PrintDataTo(StringStream* stream); - - int arity() const { return hydrogen()->argument_count() - 1; } -}; - - class LCallKeyed: public LTemplateInstruction<1, 2, 0> { public: LCallKeyed(LOperand* context, LOperand* key) { @@ -1460,7 +1477,7 @@ class LCallRuntime: public LTemplateInstruction<1, 0, 0> { DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime") DECLARE_HYDROGEN_ACCESSOR(CallRuntime) - const Runtime::Function* function() const { return hydrogen()->function(); } + Runtime::Function* function() const { return hydrogen()->function(); } int arity() const { return hydrogen()->argument_count(); } }; @@ -1505,7 +1522,7 @@ class LDoubleToI: public LTemplateInstruction<1, 1, 1> { } DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i") - DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) + DECLARE_HYDROGEN_ACCESSOR(Change) bool truncating() { return hydrogen()->CanTruncateToInt32(); } }; @@ -1520,7 +1537,7 @@ class LTaggedToI: public LTemplateInstruction<1, 1, 1> { } DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i") - DECLARE_HYDROGEN_ACCESSOR(UnaryOperation) + DECLARE_HYDROGEN_ACCESSOR(Change) bool truncating() { return hydrogen()->CanTruncateToInt32(); } }; @@ -1543,7 +1560,6 @@ class LNumberUntagD: public LTemplateInstruction<1, 1, 0> { } DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag") - DECLARE_HYDROGEN_ACCESSOR(Change); }; @@ -1604,7 +1620,6 @@ class LStoreNamedGeneric: public LTemplateInstruction<0, 3, 0> { LOperand* object() { return inputs_[1]; } LOperand* value() { return inputs_[2]; } Handle<Object> name() const { return hydrogen()->name(); } - bool strict_mode() { return hydrogen()->strict_mode(); } }; @@ -1628,26 +1643,25 @@ class LStoreKeyedFastElement: public LTemplateInstruction<0, 3, 0> { }; -class LStoreKeyedSpecializedArrayElement: public LTemplateInstruction<0, 3, 0> { +class LStorePixelArrayElement: public LTemplateInstruction<0, 3, 1> { public: - LStoreKeyedSpecializedArrayElement(LOperand* external_pointer, - LOperand* key, - LOperand* val) { + LStorePixelArrayElement(LOperand* external_pointer, + LOperand* key, + LOperand* val, + LOperand* clamped) { inputs_[0] = external_pointer; inputs_[1] = key; inputs_[2] = val; + temps_[0] = clamped; } - DECLARE_CONCRETE_INSTRUCTION(StoreKeyedSpecializedArrayElement, - "store-keyed-specialized-array-element") - DECLARE_HYDROGEN_ACCESSOR(StoreKeyedSpecializedArrayElement) + DECLARE_CONCRETE_INSTRUCTION(StorePixelArrayElement, + "store-pixel-array-element") + DECLARE_HYDROGEN_ACCESSOR(StorePixelArrayElement) 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(); - } }; @@ -1664,7 +1678,6 @@ class LStoreKeyedGeneric: public LTemplateInstruction<0, 4, 0> { } DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic") - DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric) virtual void PrintDataTo(StringStream* stream); @@ -1672,22 +1685,6 @@ class LStoreKeyedGeneric: public LTemplateInstruction<0, 4, 0> { LOperand* object() { return inputs_[1]; } LOperand* key() { return inputs_[2]; } LOperand* value() { return inputs_[3]; } - 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]; } }; @@ -1706,19 +1703,6 @@ 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) { @@ -1782,58 +1766,20 @@ class LCheckPrototypeMaps: public LTemplateInstruction<0, 0, 1> { class LCheckSmi: public LTemplateInstruction<0, 1, 0> { public: - explicit LCheckSmi(LOperand* value) { + LCheckSmi(LOperand* value, Condition condition) + : condition_(condition) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi") -}; - - -class LClampDToUint8: public LTemplateInstruction<1, 1, 0> { - public: - explicit LClampDToUint8(LOperand* value) { - inputs_[0] = value; - } - - 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]; } + Condition condition() const { return condition_; } - DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8") -}; - - -class LCheckNonSmi: public LTemplateInstruction<0, 1, 0> { - public: - explicit LCheckNonSmi(LOperand* value) { - inputs_[0] = value; + virtual void CompileToNative(LCodeGen* generator); + virtual const char* Mnemonic() const { + return (condition_ == zero) ? "check-non-smi" : "check-smi"; } - DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi") + private: + Condition condition_; }; @@ -1873,24 +1819,28 @@ class LFunctionLiteral: public LTemplateInstruction<1, 0, 0> { }; -class LToFastProperties: public LTemplateInstruction<1, 1, 0> { +class LTypeof: public LTemplateInstruction<1, 1, 0> { public: - explicit LToFastProperties(LOperand* value) { + explicit LTypeof(LOperand* value) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties") - DECLARE_HYDROGEN_ACCESSOR(ToFastProperties) + DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof") }; -class LTypeof: public LTemplateInstruction<1, 1, 0> { +class LTypeofIs: public LTemplateInstruction<1, 1, 0> { public: - explicit LTypeof(LOperand* value) { + explicit LTypeofIs(LOperand* value) { inputs_[0] = value; } - DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof") + DECLARE_CONCRETE_INSTRUCTION(TypeofIs, "typeof-is") + DECLARE_HYDROGEN_ACCESSOR(TypeofIs) + + Handle<String> type_literal() { return hydrogen()->type_literal(); } + + virtual void PrintDataTo(StringStream* stream); }; @@ -1901,7 +1851,7 @@ class LTypeofIsAndBranch: public LControlInstruction<1, 0> { } DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch") - DECLARE_HYDROGEN_ACCESSOR(TypeofIsAndBranch) + DECLARE_HYDROGEN_ACCESSOR(TypeofIs) Handle<String> type_literal() { return hydrogen()->type_literal(); } @@ -1949,35 +1899,14 @@ 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(CompilationInfo* info, HGraph* graph) + explicit LChunk(HGraph* graph) : spill_slot_count_(0), - info_(info), graph_(graph), instructions_(32), pointer_maps_(8), @@ -1994,7 +1923,6 @@ 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); @@ -2031,7 +1959,6 @@ class LChunk: public ZoneObject { private: int spill_slot_count_; - CompilationInfo* info_; HGraph* const graph_; ZoneList<LInstruction*> instructions_; ZoneList<LPointerMap*> pointer_maps_; @@ -2041,9 +1968,8 @@ class LChunk: public ZoneObject { class LChunkBuilder BASE_EMBEDDED { public: - LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator) + LChunkBuilder(HGraph* graph, LAllocator* allocator) : chunk_(NULL), - info_(info), graph_(graph), status_(UNUSED), current_instruction_(NULL), @@ -2072,7 +1998,6 @@ 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; } @@ -2179,7 +2104,6 @@ class LChunkBuilder BASE_EMBEDDED { HArithmeticBinaryOperation* instr); LChunk* chunk_; - CompilationInfo* info_; HGraph* const graph_; Status status_; HInstruction* current_instruction_; @@ -2195,6 +2119,7 @@ class LChunkBuilder BASE_EMBEDDED { }; #undef DECLARE_HYDROGEN_ACCESSOR +#undef DECLARE_INSTRUCTION #undef DECLARE_CONCRETE_INSTRUCTION } } // namespace v8::internal |