diff options
Diffstat (limited to 'deps/v8/src/hydrogen-instructions.h')
| -rw-r--r-- | deps/v8/src/hydrogen-instructions.h | 1486 |
1 files changed, 809 insertions, 677 deletions
diff --git a/deps/v8/src/hydrogen-instructions.h b/deps/v8/src/hydrogen-instructions.h index 60d2885254..7d33141a4f 100644 --- a/deps/v8/src/hydrogen-instructions.h +++ b/deps/v8/src/hydrogen-instructions.h @@ -87,12 +87,12 @@ class LChunkBuilder; V(CallStub) \ V(CapturedObject) \ V(Change) \ - V(CheckFunction) \ V(CheckHeapObject) \ V(CheckInstanceType) \ V(CheckMaps) \ V(CheckMapValue) \ V(CheckSmi) \ + V(CheckValue) \ V(ClampToUint8) \ V(ClassOfTestAndBranch) \ V(CompareNumericAndBranch) \ @@ -163,6 +163,7 @@ class LChunkBuilder; V(Shr) \ V(Simulate) \ V(StackCheck) \ + V(StoreCodeEntry) \ V(StoreContextSlot) \ V(StoreGlobalCell) \ V(StoreGlobalGeneric) \ @@ -209,24 +210,27 @@ class LChunkBuilder; V(ExternalMemory) -#define DECLARE_ABSTRACT_INSTRUCTION(type) \ - virtual bool Is##type() const { return true; } \ - static H##type* cast(HValue* value) { \ - ASSERT(value->Is##type()); \ - return reinterpret_cast<H##type*>(value); \ +#define DECLARE_ABSTRACT_INSTRUCTION(type) \ + virtual bool Is##type() const V8_FINAL V8_OVERRIDE { return true; } \ + static H##type* cast(HValue* value) { \ + ASSERT(value->Is##type()); \ + return reinterpret_cast<H##type*>(value); \ } -#define DECLARE_CONCRETE_INSTRUCTION(type) \ - virtual LInstruction* CompileToLithium(LChunkBuilder* builder); \ - static H##type* cast(HValue* value) { \ - ASSERT(value->Is##type()); \ - return reinterpret_cast<H##type*>(value); \ - } \ - virtual Opcode opcode() const { return HValue::k##type; } +#define DECLARE_CONCRETE_INSTRUCTION(type) \ + virtual LInstruction* CompileToLithium( \ + LChunkBuilder* builder) V8_FINAL V8_OVERRIDE; \ + static H##type* cast(HValue* value) { \ + ASSERT(value->Is##type()); \ + return reinterpret_cast<H##type*>(value); \ + } \ + virtual Opcode opcode() const V8_FINAL V8_OVERRIDE { \ + return HValue::k##type; \ + } -class Range: public ZoneObject { +class Range V8_FINAL : public ZoneObject { public: Range() : lower_(kMinInt), @@ -301,16 +305,12 @@ class Range: public ZoneObject { }; -class UniqueValueId { +class UniqueValueId V8_FINAL { public: UniqueValueId() : raw_address_(NULL) { } - explicit UniqueValueId(Object* object) { - raw_address_ = reinterpret_cast<Address>(object); - ASSERT(IsInitialized()); - } - explicit UniqueValueId(Handle<Object> handle) { + ASSERT(!AllowHeapAllocation::IsAllowed()); static const Address kEmptyHandleSentinel = reinterpret_cast<Address>(1); if (handle.is_null()) { raw_address_ = kEmptyHandleSentinel; @@ -338,12 +338,32 @@ class UniqueValueId { return reinterpret_cast<intptr_t>(raw_address_); } +#define IMMOVABLE_UNIQUE_VALUE_ID(name) \ + static UniqueValueId name(Heap* heap) { return UniqueValueId(heap->name()); } + + IMMOVABLE_UNIQUE_VALUE_ID(free_space_map) + IMMOVABLE_UNIQUE_VALUE_ID(minus_zero_value) + IMMOVABLE_UNIQUE_VALUE_ID(nan_value) + IMMOVABLE_UNIQUE_VALUE_ID(undefined_value) + IMMOVABLE_UNIQUE_VALUE_ID(null_value) + IMMOVABLE_UNIQUE_VALUE_ID(true_value) + IMMOVABLE_UNIQUE_VALUE_ID(false_value) + IMMOVABLE_UNIQUE_VALUE_ID(the_hole_value) + IMMOVABLE_UNIQUE_VALUE_ID(empty_string) + +#undef IMMOVABLE_UNIQUE_VALUE_ID + private: Address raw_address_; + + explicit UniqueValueId(Object* object) { + raw_address_ = reinterpret_cast<Address>(object); + ASSERT(IsInitialized()); + } }; -class HType { +class HType V8_FINAL { public: static HType None() { return HType(kNone); } static HType Tagged() { return HType(kTagged); } @@ -370,10 +390,6 @@ class HType { return Combine(other).Equals(other); } - bool IsTagged() const { - return ((type_ & kTagged) == kTagged); - } - bool IsTaggedPrimitive() const { return ((type_ & kTaggedPrimitive) == kTaggedPrimitive); } @@ -494,7 +510,7 @@ class HUseListNode: public ZoneObject { // We reuse use list nodes behind the scenes as uses are added and deleted. // This class is the safe way to iterate uses while deleting them. -class HUseIterator BASE_EMBEDDED { +class HUseIterator V8_FINAL BASE_EMBEDDED { public: bool Done() { return current_ == NULL; } void Advance(); @@ -538,7 +554,7 @@ enum GVNFlag { }; -class DecompositionResult BASE_EMBEDDED { +class DecompositionResult V8_FINAL BASE_EMBEDDED { public: DecompositionResult() : base_(NULL), offset_(0), scale_(0) {} @@ -586,7 +602,7 @@ class DecompositionResult BASE_EMBEDDED { typedef EnumSet<GVNFlag> GVNFlagSet; -class HValue: public ZoneObject { +class HValue : public ZoneObject { public: static const int kNoNumber = -1; @@ -802,6 +818,8 @@ class HValue: public ZoneObject { // Returns true if the flag specified is set for all uses, false otherwise. bool CheckUsesForFlag(Flag f) const; + // Same as before and the first one without the flag is returned in value. + bool CheckUsesForFlag(Flag f, HValue** value) const; // Returns true if the flag specified is set for all uses, and this set // of uses is non-empty. bool HasAtLeastOneUseWithFlagAndNoneWithout(Flag f) const; @@ -861,6 +879,7 @@ class HValue: public ZoneObject { // Escape analysis helpers. virtual bool HasEscapingOperandAt(int index) { return true; } + virtual bool HasOutOfBoundsAccess(int size) { return false; } // Representation helpers. virtual Representation observed_input_representation(int index) { @@ -878,7 +897,7 @@ class HValue: public ZoneObject { bool Equals(HValue* other); virtual intptr_t Hashcode(); - // Compute unique ids upfront that is safe wrt GC and parallel recompilation. + // Compute unique ids upfront that is safe wrt GC and concurrent compilation. virtual void FinalizeUniqueValueId() { } // Printing support. @@ -941,6 +960,11 @@ class HValue: public ZoneObject { return type().ToStringOrToNumberCanBeObserved(representation()); } + MinusZeroMode GetMinusZeroMode() { + return CheckFlag(kBailoutOnMinusZero) + ? FAIL_ON_MINUS_ZERO : TREAT_MINUS_ZERO_AS_ZERO; + } + protected: // This function must be overridden for instructions with flag kUseGVN, to // compare the non-Operand parts of the instruction. @@ -1081,12 +1105,12 @@ class HValue: public ZoneObject { } -class HInstruction: public HValue { +class HInstruction : public HValue { public: HInstruction* next() const { return next_; } HInstruction* previous() const { return previous_; } - virtual void PrintTo(StringStream* stream); + virtual void PrintTo(StringStream* stream) V8_OVERRIDE; virtual void PrintDataTo(StringStream* stream); bool IsLinked() const { return block() != NULL; } @@ -1108,7 +1132,7 @@ class HInstruction: public HValue { virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0; #ifdef DEBUG - virtual void Verify(); + virtual void Verify() V8_OVERRIDE; #endif virtual bool IsCall() { return false; } @@ -1124,7 +1148,7 @@ class HInstruction: public HValue { SetGVNFlag(kDependsOnOsrEntries); } - virtual void DeleteFromGraph() { Unlink(); } + virtual void DeleteFromGraph() V8_OVERRIDE { Unlink(); } private: void InitializeAsFirst(HBasicBlock* block) { @@ -1145,26 +1169,30 @@ class HInstruction: public HValue { template<int V> class HTemplateInstruction : public HInstruction { public: - int OperandCount() { return V; } - HValue* OperandAt(int i) const { return inputs_[i]; } + virtual int OperandCount() V8_FINAL V8_OVERRIDE { return V; } + virtual HValue* OperandAt(int i) const V8_FINAL V8_OVERRIDE { + return inputs_[i]; + } protected: HTemplateInstruction(HType type = HType::Tagged()) : HInstruction(type) {} - void InternalSetOperandAt(int i, HValue* value) { inputs_[i] = value; } + virtual void InternalSetOperandAt(int i, HValue* value) V8_FINAL V8_OVERRIDE { + inputs_[i] = value; + } private: EmbeddedContainer<HValue*, V> inputs_; }; -class HControlInstruction: public HInstruction { +class HControlInstruction : public HInstruction { public: virtual HBasicBlock* SuccessorAt(int i) = 0; virtual int SuccessorCount() = 0; virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0; - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HBasicBlock* FirstSuccessor() { return SuccessorCount() > 0 ? SuccessorAt(0) : NULL; @@ -1177,7 +1205,7 @@ class HControlInstruction: public HInstruction { }; -class HSuccessorIterator BASE_EMBEDDED { +class HSuccessorIterator V8_FINAL BASE_EMBEDDED { public: explicit HSuccessorIterator(HControlInstruction* instr) : instr_(instr), current_(0) { } @@ -1193,18 +1221,22 @@ class HSuccessorIterator BASE_EMBEDDED { template<int S, int V> -class HTemplateControlInstruction: public HControlInstruction { +class HTemplateControlInstruction : public HControlInstruction { public: - int SuccessorCount() { return S; } - HBasicBlock* SuccessorAt(int i) { return successors_[i]; } - void SetSuccessorAt(int i, HBasicBlock* block) { successors_[i] = block; } + int SuccessorCount() V8_OVERRIDE { return S; } + HBasicBlock* SuccessorAt(int i) V8_OVERRIDE { return successors_[i]; } + void SetSuccessorAt(int i, HBasicBlock* block) V8_OVERRIDE { + successors_[i] = block; + } - int OperandCount() { return V; } - HValue* OperandAt(int i) const { return inputs_[i]; } + int OperandCount() V8_OVERRIDE { return V; } + HValue* OperandAt(int i) const V8_OVERRIDE { return inputs_[i]; } protected: - void InternalSetOperandAt(int i, HValue* value) { inputs_[i] = value; } + void InternalSetOperandAt(int i, HValue* value) V8_OVERRIDE { + inputs_[i] = value; + } private: EmbeddedContainer<HBasicBlock*, S> successors_; @@ -1212,9 +1244,9 @@ class HTemplateControlInstruction: public HControlInstruction { }; -class HBlockEntry: public HTemplateInstruction<0> { +class HBlockEntry V8_FINAL : public HTemplateInstruction<0> { public: - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -1222,7 +1254,7 @@ class HBlockEntry: public HTemplateInstruction<0> { }; -class HDummyUse: public HTemplateInstruction<1> { +class HDummyUse V8_FINAL : public HTemplateInstruction<1> { public: explicit HDummyUse(HValue* value) : HTemplateInstruction<1>(HType::Smi()) { @@ -1234,23 +1266,23 @@ class HDummyUse: public HTemplateInstruction<1> { HValue* value() { return OperandAt(0); } - virtual bool HasEscapingOperandAt(int index) { return false; } - virtual Representation RequiredInputRepresentation(int index) { + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; } + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(DummyUse); }; -class HDeoptimize: public HTemplateInstruction<0> { +class HDeoptimize V8_FINAL : public HTemplateInstruction<0> { public: DECLARE_INSTRUCTION_FACTORY_P2(HDeoptimize, const char*, Deoptimizer::BailoutType); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -1269,9 +1301,9 @@ class HDeoptimize: public HTemplateInstruction<0> { // Inserts an int3/stop break instruction for debugging purposes. -class HDebugBreak: public HTemplateInstruction<0> { +class HDebugBreak V8_FINAL : public HTemplateInstruction<0> { public: - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -1279,23 +1311,23 @@ class HDebugBreak: public HTemplateInstruction<0> { }; -class HGoto: public HTemplateControlInstruction<1, 0> { +class HGoto V8_FINAL : public HTemplateControlInstruction<1, 0> { public: explicit HGoto(HBasicBlock* target) { SetSuccessorAt(0, target); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(Goto) }; -class HUnaryControlInstruction: public HTemplateControlInstruction<2, 1> { +class HUnaryControlInstruction : public HTemplateControlInstruction<2, 1> { public: HUnaryControlInstruction(HValue* value, HBasicBlock* true_target, @@ -1305,13 +1337,13 @@ class HUnaryControlInstruction: public HTemplateControlInstruction<2, 1> { SetSuccessorAt(1, false_target); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HValue* value() { return OperandAt(0); } }; -class HBranch: public HUnaryControlInstruction { +class HBranch V8_FINAL : public HUnaryControlInstruction { public: HBranch(HValue* value, ToBooleanStub::Types expected_input_types = ToBooleanStub::Types(), @@ -1322,10 +1354,10 @@ class HBranch: public HUnaryControlInstruction { SetFlag(kAllowUndefinedAsNaN); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } - virtual Representation observed_input_representation(int index); + virtual Representation observed_input_representation(int index) V8_OVERRIDE; ToBooleanStub::Types expected_input_types() const { return expected_input_types_; @@ -1338,7 +1370,7 @@ class HBranch: public HUnaryControlInstruction { }; -class HCompareMap: public HUnaryControlInstruction { +class HCompareMap V8_FINAL : public HUnaryControlInstruction { public: HCompareMap(HValue* value, Handle<Map> map, @@ -1349,35 +1381,38 @@ class HCompareMap: public HUnaryControlInstruction { ASSERT(!map.is_null()); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; Handle<Map> map() const { return map_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(CompareMap) + protected: + virtual int RedefinedOperandIndex() { return 0; } + private: Handle<Map> map_; }; -class HContext: public HTemplateInstruction<0> { +class HContext V8_FINAL : public HTemplateInstruction<0> { public: static HContext* New(Zone* zone) { return new(zone) HContext(); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } DECLARE_CONCRETE_INSTRUCTION(Context) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: HContext() { @@ -1385,11 +1420,11 @@ class HContext: public HTemplateInstruction<0> { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HReturn: public HTemplateControlInstruction<0, 3> { +class HReturn V8_FINAL : public HTemplateControlInstruction<0, 3> { public: static HInstruction* New(Zone* zone, HValue* context, @@ -1404,11 +1439,11 @@ class HReturn: public HTemplateControlInstruction<0, 3> { return new(zone) HReturn(value, context, 0); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HValue* value() { return OperandAt(0); } HValue* context() { return OperandAt(1); } @@ -1425,7 +1460,7 @@ class HReturn: public HTemplateControlInstruction<0, 3> { }; -class HUnaryOperation: public HTemplateInstruction<1> { +class HUnaryOperation : public HTemplateInstruction<1> { public: HUnaryOperation(HValue* value, HType type = HType::Tagged()) : HTemplateInstruction<1>(type) { @@ -1437,11 +1472,11 @@ class HUnaryOperation: public HTemplateInstruction<1> { } HValue* value() const { return OperandAt(0); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; }; -class HThrow: public HTemplateInstruction<2> { +class HThrow V8_FINAL : public HTemplateInstruction<2> { public: static HThrow* New(Zone* zone, HValue* context, @@ -1449,7 +1484,7 @@ class HThrow: public HTemplateInstruction<2> { return new(zone) HThrow(context, value); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -1467,11 +1502,11 @@ class HThrow: public HTemplateInstruction<2> { }; -class HUseConst: public HUnaryOperation { +class HUseConst V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HUseConst, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -1482,19 +1517,20 @@ class HUseConst: public HUnaryOperation { }; -class HForceRepresentation: public HTemplateInstruction<1> { +class HForceRepresentation V8_FINAL : public HTemplateInstruction<1> { public: DECLARE_INSTRUCTION_FACTORY_P2(HForceRepresentation, HValue*, Representation); HValue* value() { return OperandAt(0); } - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return representation(); // Same as the output representation. } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(ForceRepresentation) @@ -1506,7 +1542,7 @@ class HForceRepresentation: public HTemplateInstruction<1> { }; -class HChange: public HUnaryOperation { +class HChange V8_FINAL : public HUnaryOperation { public: HChange(HValue* value, Representation to, @@ -1518,7 +1554,10 @@ class HChange: public HUnaryOperation { ASSERT(!value->representation().Equals(to)); set_representation(to); SetFlag(kUseGVN); - if (is_truncating_to_smi) SetFlag(kTruncatingToSmi); + if (is_truncating_to_smi) { + SetFlag(kTruncatingToSmi); + SetFlag(kTruncatingToInt32); + } if (is_truncating_to_int32) SetFlag(kTruncatingToInt32); if (value->representation().IsSmi() || value->type().IsSmi()) { set_type(HType::Smi()); @@ -1532,47 +1571,48 @@ class HChange: public HUnaryOperation { return CheckUsesForFlag(kAllowUndefinedAsNaN); } - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); - virtual HType CalculateInferredType(); - virtual HValue* Canonicalize(); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; + virtual HType CalculateInferredType() V8_OVERRIDE; + virtual HValue* Canonicalize() V8_OVERRIDE; Representation from() const { return value()->representation(); } Representation to() const { return representation(); } bool deoptimize_on_minus_zero() const { return CheckFlag(kBailoutOnMinusZero); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return from(); } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(Change) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: - virtual bool IsDeletable() const { + virtual bool IsDeletable() const V8_OVERRIDE { return !from().IsTagged() || value()->type().IsSmi(); } }; -class HClampToUint8: public HUnaryOperation { +class HClampToUint8 V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HClampToUint8, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } DECLARE_CONCRETE_INSTRUCTION(ClampToUint8) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HClampToUint8(HValue* value) @@ -1582,7 +1622,7 @@ class HClampToUint8: public HUnaryOperation { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; @@ -1592,7 +1632,7 @@ enum RemovableSimulate { }; -class HSimulate: public HInstruction { +class HSimulate V8_FINAL : public HInstruction { public: HSimulate(BailoutId ast_id, int pop_count, @@ -1604,9 +1644,9 @@ class HSimulate: public HInstruction { assigned_indexes_(2, zone), zone_(zone), removable_(removable) {} - virtual ~HSimulate() {} + ~HSimulate() {} - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; bool HasAstId() const { return !ast_id_.IsNone(); } BailoutId ast_id() const { return ast_id_; } @@ -1636,27 +1676,32 @@ class HSimulate: public HInstruction { } return -1; } - virtual int OperandCount() { return values_.length(); } - virtual HValue* OperandAt(int index) const { return values_[index]; } + virtual int OperandCount() V8_OVERRIDE { return values_.length(); } + virtual HValue* OperandAt(int index) const V8_OVERRIDE { + return values_[index]; + } - virtual bool HasEscapingOperandAt(int index) { return false; } - virtual Representation RequiredInputRepresentation(int index) { + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; } + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } void MergeWith(ZoneList<HSimulate*>* list); bool is_candidate_for_removal() { return removable_ == REMOVABLE_SIMULATE; } + // Replay effects of this instruction on the given environment. + void ReplayEnvironment(HEnvironment* env); + DECLARE_CONCRETE_INSTRUCTION(Simulate) #ifdef DEBUG - virtual void Verify(); + virtual void Verify() V8_OVERRIDE; void set_closure(Handle<JSFunction> closure) { closure_ = closure; } Handle<JSFunction> closure() const { return closure_; } #endif protected: - virtual void InternalSetOperandAt(int index, HValue* value) { + virtual void InternalSetOperandAt(int index, HValue* value) V8_OVERRIDE { values_[index] = value; } @@ -1689,7 +1734,7 @@ class HSimulate: public HInstruction { }; -class HEnvironmentMarker: public HTemplateInstruction<1> { +class HEnvironmentMarker V8_FINAL : public HTemplateInstruction<1> { public: enum Kind { BIND, LOOKUP }; @@ -1703,11 +1748,11 @@ class HEnvironmentMarker: public HTemplateInstruction<1> { next_simulate_ = simulate; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; #ifdef DEBUG void set_closure(Handle<JSFunction> closure) { @@ -1731,7 +1776,7 @@ class HEnvironmentMarker: public HTemplateInstruction<1> { }; -class HStackCheck: public HTemplateInstruction<1> { +class HStackCheck V8_FINAL : public HTemplateInstruction<1> { public: enum Type { kFunctionEntry, @@ -1742,7 +1787,7 @@ class HStackCheck: public HTemplateInstruction<1> { HValue* context() { return OperandAt(0); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -1781,7 +1826,7 @@ enum InliningKind { class HArgumentsObject; -class HEnterInlined: public HTemplateInstruction<0> { +class HEnterInlined V8_FINAL : public HTemplateInstruction<0> { public: static HEnterInlined* New(Zone* zone, HValue* context, @@ -1800,7 +1845,7 @@ class HEnterInlined: public HTemplateInstruction<0> { void RegisterReturnTarget(HBasicBlock* return_target, Zone* zone); ZoneList<HBasicBlock*>* return_targets() { return &return_targets_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; Handle<JSFunction> closure() const { return closure_; } int arguments_count() const { return arguments_count_; } @@ -1810,7 +1855,7 @@ class HEnterInlined: public HTemplateInstruction<0> { InliningKind inlining_kind() const { return inlining_kind_; } bool undefined_receiver() const { return undefined_receiver_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -1851,11 +1896,11 @@ class HEnterInlined: public HTemplateInstruction<0> { }; -class HLeaveInlined: public HTemplateInstruction<0> { +class HLeaveInlined V8_FINAL : public HTemplateInstruction<0> { public: HLeaveInlined() { } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -1863,11 +1908,11 @@ class HLeaveInlined: public HTemplateInstruction<0> { }; -class HPushArgument: public HUnaryOperation { +class HPushArgument V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HPushArgument, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -1882,39 +1927,39 @@ class HPushArgument: public HUnaryOperation { }; -class HThisFunction: public HTemplateInstruction<0> { +class HThisFunction V8_FINAL : public HTemplateInstruction<0> { public: HThisFunction() { set_representation(Representation::Tagged()); SetFlag(kUseGVN); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } DECLARE_CONCRETE_INSTRUCTION(ThisFunction) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HOuterContext: public HUnaryOperation { +class HOuterContext V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HOuterContext, HValue*); DECLARE_CONCRETE_INSTRUCTION(OuterContext); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HOuterContext(HValue* inner) : HUnaryOperation(inner) { @@ -1922,11 +1967,11 @@ class HOuterContext: public HUnaryOperation { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HDeclareGlobals: public HUnaryOperation { +class HDeclareGlobals V8_FINAL : public HUnaryOperation { public: HDeclareGlobals(HValue* context, Handle<FixedArray> pairs, @@ -1951,7 +1996,7 @@ class HDeclareGlobals: public HUnaryOperation { DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals) - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -1961,7 +2006,7 @@ class HDeclareGlobals: public HUnaryOperation { }; -class HGlobalObject: public HUnaryOperation { +class HGlobalObject V8_FINAL : public HUnaryOperation { public: explicit HGlobalObject(HValue* context) : HUnaryOperation(context) { set_representation(Representation::Tagged()); @@ -1974,30 +2019,30 @@ class HGlobalObject: public HUnaryOperation { DECLARE_CONCRETE_INSTRUCTION(GlobalObject) - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HGlobalReceiver: public HUnaryOperation { +class HGlobalReceiver V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HGlobalReceiver, HValue*); DECLARE_CONCRETE_INSTRUCTION(GlobalReceiver) - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HGlobalReceiver(HValue* global_object) @@ -2006,12 +2051,12 @@ class HGlobalReceiver: public HUnaryOperation { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; template <int V> -class HCall: public HTemplateInstruction<V> { +class HCall : public HTemplateInstruction<V> { public: // The argument count includes the receiver. explicit HCall<V>(int argument_count) : argument_count_(argument_count) { @@ -2019,35 +2064,38 @@ class HCall: public HTemplateInstruction<V> { this->SetAllSideEffects(); } - virtual HType CalculateInferredType() { return HType::Tagged(); } + virtual HType CalculateInferredType() V8_FINAL V8_OVERRIDE { + return HType::Tagged(); + } virtual int argument_count() const { return argument_count_; } - virtual bool IsCall() { return true; } + virtual bool IsCall() V8_FINAL V8_OVERRIDE { return true; } private: int argument_count_; }; -class HUnaryCall: public HCall<1> { +class HUnaryCall : public HCall<1> { public: HUnaryCall(HValue* value, int argument_count) : HCall<1>(argument_count) { SetOperandAt(0, value); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation( + int index) V8_FINAL V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HValue* value() { return OperandAt(0); } }; -class HBinaryCall: public HCall<2> { +class HBinaryCall : public HCall<2> { public: HBinaryCall(HValue* first, HValue* second, int argument_count) : HCall<2>(argument_count) { @@ -2055,9 +2103,10 @@ class HBinaryCall: public HCall<2> { SetOperandAt(1, second); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation( + int index) V8_FINAL V8_OVERRIDE { return Representation::Tagged(); } @@ -2066,7 +2115,7 @@ class HBinaryCall: public HCall<2> { }; -class HInvokeFunction: public HBinaryCall { +class HInvokeFunction V8_FINAL : public HBinaryCall { public: HInvokeFunction(HValue* context, HValue* function, int argument_count) : HBinaryCall(context, function, argument_count) { @@ -2098,10 +2147,6 @@ class HInvokeFunction: public HBinaryCall { known_function, argument_count); } - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Tagged(); - } - HValue* context() { return first(); } HValue* function() { return second(); } Handle<JSFunction> known_function() { return known_function_; } @@ -2115,7 +2160,7 @@ class HInvokeFunction: public HBinaryCall { }; -class HCallConstantFunction: public HCall<0> { +class HCallConstantFunction V8_FINAL : public HCall<0> { public: HCallConstantFunction(Handle<JSFunction> function, int argument_count) : HCall<0>(argument_count), @@ -2127,12 +2172,12 @@ class HCallConstantFunction: public HCall<0> { bool IsApplyFunction() const { return function_->code() == - Isolate::Current()->builtins()->builtin(Builtins::kFunctionApply); + function_->GetIsolate()->builtins()->builtin(Builtins::kFunctionApply); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -2144,16 +2189,12 @@ class HCallConstantFunction: public HCall<0> { }; -class HCallKeyed: public HBinaryCall { +class HCallKeyed V8_FINAL : public HBinaryCall { public: HCallKeyed(HValue* context, HValue* key, int argument_count) : HBinaryCall(context, key, argument_count) { } - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Tagged(); - } - HValue* context() { return first(); } HValue* key() { return second(); } @@ -2161,29 +2202,25 @@ class HCallKeyed: public HBinaryCall { }; -class HCallNamed: public HUnaryCall { +class HCallNamed V8_FINAL : public HUnaryCall { public: HCallNamed(HValue* context, Handle<String> name, int argument_count) : HUnaryCall(context, argument_count), name_(name) { } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HValue* context() { return value(); } Handle<String> name() const { return name_; } DECLARE_CONCRETE_INSTRUCTION(CallNamed) - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Tagged(); - } - private: Handle<String> name_; }; -class HCallFunction: public HBinaryCall { +class HCallFunction V8_FINAL : public HBinaryCall { public: HCallFunction(HValue* context, HValue* function, int argument_count) : HBinaryCall(context, function, argument_count) { @@ -2199,15 +2236,11 @@ class HCallFunction: public HBinaryCall { HValue* context() { return first(); } HValue* function() { return second(); } - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Tagged(); - } - DECLARE_CONCRETE_INSTRUCTION(CallFunction) }; -class HCallGlobal: public HUnaryCall { +class HCallGlobal V8_FINAL : public HUnaryCall { public: HCallGlobal(HValue* context, Handle<String> name, int argument_count) : HUnaryCall(context, argument_count), name_(name) { @@ -2220,15 +2253,11 @@ class HCallGlobal: public HUnaryCall { return new(zone) HCallGlobal(context, name, argument_count); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HValue* context() { return value(); } Handle<String> name() const { return name_; } - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Tagged(); - } - DECLARE_CONCRETE_INSTRUCTION(CallGlobal) private: @@ -2236,19 +2265,19 @@ class HCallGlobal: public HUnaryCall { }; -class HCallKnownGlobal: public HCall<0> { +class HCallKnownGlobal V8_FINAL : public HCall<0> { public: HCallKnownGlobal(Handle<JSFunction> target, int argument_count) : HCall<0>(argument_count), target_(target), formal_parameter_count_(target->shared()->formal_parameter_count()) { } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; Handle<JSFunction> target() const { return target_; } int formal_parameter_count() const { return formal_parameter_count_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -2260,15 +2289,10 @@ class HCallKnownGlobal: public HCall<0> { }; -class HCallNew: public HBinaryCall { +class HCallNew V8_FINAL : public HBinaryCall { public: HCallNew(HValue* context, HValue* constructor, int argument_count) - : HBinaryCall(context, constructor, argument_count) { - } - - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Tagged(); - } + : HBinaryCall(context, constructor, argument_count) {} HValue* context() { return first(); } HValue* constructor() { return second(); } @@ -2277,15 +2301,18 @@ class HCallNew: public HBinaryCall { }; -class HCallNewArray: public HCallNew { +class HCallNewArray V8_FINAL : public HBinaryCall { public: HCallNewArray(HValue* context, HValue* constructor, int argument_count, Handle<Cell> type_cell, ElementsKind elements_kind) - : HCallNew(context, constructor, argument_count), + : HBinaryCall(context, constructor, argument_count), elements_kind_(elements_kind), type_cell_(type_cell) {} - virtual void PrintDataTo(StringStream* stream); + HValue* context() { return first(); } + HValue* constructor() { return second(); } + + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; Handle<Cell> property_cell() const { return type_cell_; @@ -2301,7 +2328,7 @@ class HCallNewArray: public HCallNew { }; -class HCallRuntime: public HCall<1> { +class HCallRuntime V8_FINAL : public HCall<1> { public: static HCallRuntime* New(Zone* zone, HValue* context, @@ -2311,13 +2338,13 @@ class HCallRuntime: public HCall<1> { return new(zone) HCallRuntime(context, name, c_function, argument_count); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HValue* context() { return OperandAt(0); } const Runtime::Function* function() const { return c_function_; } Handle<String> name() const { return name_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -2337,18 +2364,18 @@ class HCallRuntime: public HCall<1> { }; -class HMapEnumLength: public HUnaryOperation { +class HMapEnumLength V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HMapEnumLength, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(MapEnumLength) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HMapEnumLength(HValue* value) @@ -2358,11 +2385,11 @@ class HMapEnumLength: public HUnaryOperation { SetGVNFlag(kDependsOnMaps); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HElementsKind: public HUnaryOperation { +class HElementsKind V8_FINAL : public HUnaryOperation { public: explicit HElementsKind(HValue* value) : HUnaryOperation(value) { set_representation(Representation::Integer32()); @@ -2370,21 +2397,21 @@ class HElementsKind: public HUnaryOperation { SetGVNFlag(kDependsOnElementsKind); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(ElementsKind) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HUnaryMathOperation: public HTemplateInstruction<2> { +class HUnaryMathOperation V8_FINAL : public HTemplateInstruction<2> { public: static HInstruction* New(Zone* zone, HValue* context, @@ -2394,11 +2421,12 @@ class HUnaryMathOperation: public HTemplateInstruction<2> { HValue* context() { return OperandAt(0); } HValue* value() { return OperandAt(1); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { if (index == 0) { return Representation::Tagged(); } else { @@ -2422,10 +2450,10 @@ class HUnaryMathOperation: public HTemplateInstruction<2> { } } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; - virtual HValue* Canonicalize(); - virtual Representation RepresentationFromInputs(); + virtual HValue* Canonicalize() V8_OVERRIDE; + virtual Representation RepresentationFromInputs() V8_OVERRIDE; BuiltinFunctionId op() const { return op_; } const char* OpName() const; @@ -2433,7 +2461,7 @@ class HUnaryMathOperation: public HTemplateInstruction<2> { DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { HUnaryMathOperation* b = HUnaryMathOperation::cast(other); return op_ == b->op(); } @@ -2475,28 +2503,28 @@ class HUnaryMathOperation: public HTemplateInstruction<2> { SetFlag(kAllowUndefinedAsNaN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } BuiltinFunctionId op_; }; -class HLoadExternalArrayPointer: public HUnaryOperation { +class HLoadExternalArrayPointer V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HLoadExternalArrayPointer, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual HType CalculateInferredType() { + virtual HType CalculateInferredType() V8_OVERRIDE { return HType::None(); } DECLARE_CONCRETE_INSTRUCTION(LoadExternalArrayPointer) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HLoadExternalArrayPointer(HValue* value) @@ -2509,11 +2537,11 @@ class HLoadExternalArrayPointer: public HUnaryOperation { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HCheckMaps: public HTemplateInstruction<2> { +class HCheckMaps V8_FINAL : public HTemplateInstruction<2> { public: static HCheckMaps* New(Zone* zone, HValue* context, HValue* value, Handle<Map> map, CompilationInfo* info, @@ -2531,27 +2559,28 @@ class HCheckMaps: public HTemplateInstruction<2> { bool CanOmitMapChecks() { return omit_; } - virtual bool HasEscapingOperandAt(int index) { return false; } - virtual Representation RequiredInputRepresentation(int index) { + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; } + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } virtual void HandleSideEffectDominator(GVNFlag side_effect, - HValue* dominator); - virtual void PrintDataTo(StringStream* stream); + HValue* dominator) V8_OVERRIDE; + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HValue* value() { return OperandAt(0); } SmallMapList* map_set() { return &map_set_; } + ZoneList<UniqueValueId>* map_unique_ids() { return &map_unique_ids_; } bool has_migration_target() { return has_migration_target_; } - virtual void FinalizeUniqueValueId(); + virtual void FinalizeUniqueValueId() V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(CheckMaps) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { ASSERT_EQ(map_set_.length(), map_unique_ids_.length()); HCheckMaps* b = HCheckMaps::cast(other); // Relies on the fact that map_set has been sorted before. @@ -2566,6 +2595,8 @@ class HCheckMaps: public HTemplateInstruction<2> { return true; } + virtual int RedefinedOperandIndex() { return 0; } + private: void Add(Handle<Map> map, Zone* zone) { map_set_.Add(map, zone); @@ -2594,6 +2625,7 @@ class HCheckMaps: public HTemplateInstruction<2> { omit_ = true; for (int i = 0; i < map_set_.length(); i++) { Handle<Map> map = map_set_.at(i); + if (!map->CanTransition()) continue; map->AddDependentCompilationInfo(DependentCode::kPrototypeCheckGroup, info); } @@ -2606,52 +2638,62 @@ class HCheckMaps: public HTemplateInstruction<2> { }; -class HCheckFunction: public HUnaryOperation { +class HCheckValue V8_FINAL : public HUnaryOperation { public: - DECLARE_INSTRUCTION_FACTORY_P2(HCheckFunction, HValue*, Handle<JSFunction>); + static HCheckValue* New(Zone* zone, HValue* context, + HValue* value, Handle<JSFunction> target) { + bool in_new_space = zone->isolate()->heap()->InNewSpace(*target); + HCheckValue* check = new(zone) HCheckValue(value, target, in_new_space); + return check; + } + static HCheckValue* New(Zone* zone, HValue* context, + HValue* value, Handle<Map> map, UniqueValueId id) { + HCheckValue* check = new(zone) HCheckValue(value, map, false); + check->object_unique_id_ = id; + return check; + } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; #ifdef DEBUG - virtual void Verify(); + virtual void Verify() V8_OVERRIDE; #endif - virtual void FinalizeUniqueValueId() { - target_unique_id_ = UniqueValueId(target_); + virtual void FinalizeUniqueValueId() V8_OVERRIDE { + object_unique_id_ = UniqueValueId(object_); } - Handle<JSFunction> target() const { return target_; } - bool target_in_new_space() const { return target_in_new_space_; } + Handle<HeapObject> object() const { return object_; } + bool object_in_new_space() const { return object_in_new_space_; } - DECLARE_CONCRETE_INSTRUCTION(CheckFunction) + DECLARE_CONCRETE_INSTRUCTION(CheckValue) protected: - virtual bool DataEquals(HValue* other) { - HCheckFunction* b = HCheckFunction::cast(other); - return target_unique_id_ == b->target_unique_id_; + virtual bool DataEquals(HValue* other) V8_OVERRIDE { + HCheckValue* b = HCheckValue::cast(other); + return object_unique_id_ == b->object_unique_id_; } private: - HCheckFunction(HValue* value, Handle<JSFunction> function) + HCheckValue(HValue* value, Handle<HeapObject> object, bool in_new_space) : HUnaryOperation(value, value->type()), - target_(function), target_unique_id_() { + object_(object), object_in_new_space_(in_new_space) { set_representation(Representation::Tagged()); SetFlag(kUseGVN); - target_in_new_space_ = Isolate::Current()->heap()->InNewSpace(*function); } - Handle<JSFunction> target_; - UniqueValueId target_unique_id_; - bool target_in_new_space_; + Handle<HeapObject> object_; + UniqueValueId object_unique_id_; + bool object_in_new_space_; }; -class HCheckInstanceType: public HUnaryOperation { +class HCheckInstanceType V8_FINAL : public HUnaryOperation { public: static HCheckInstanceType* NewIsSpecObject(HValue* value, Zone* zone) { return new(zone) HCheckInstanceType(value, IS_SPEC_OBJECT); @@ -2667,13 +2709,13 @@ class HCheckInstanceType: public HUnaryOperation { return new(zone) HCheckInstanceType(value, IS_INTERNALIZED_STRING); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; bool is_interval_check() const { return check_ <= LAST_INTERVAL_CHECK; } void GetCheckInterval(InstanceType* first, InstanceType* last); @@ -2685,11 +2727,13 @@ class HCheckInstanceType: public HUnaryOperation { // TODO(ager): It could be nice to allow the ommision of instance // type checks if we have already performed an instance type check // with a larger range. - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { HCheckInstanceType* b = HCheckInstanceType::cast(other); return check_ == b->check_; } + virtual int RedefinedOperandIndex() { return 0; } + private: enum Check { IS_SPEC_OBJECT, @@ -2711,15 +2755,15 @@ class HCheckInstanceType: public HUnaryOperation { }; -class HCheckSmi: public HUnaryOperation { +class HCheckSmi V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HCheckSmi, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual HValue* Canonicalize() { + virtual HValue* Canonicalize() V8_OVERRIDE { HType value_type = value()->type(); if (value_type.IsSmi()) { return NULL; @@ -2730,7 +2774,7 @@ class HCheckSmi: public HUnaryOperation { DECLARE_CONCRETE_INSTRUCTION(CheckSmi) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) { @@ -2740,14 +2784,14 @@ class HCheckSmi: public HUnaryOperation { }; -class HIsNumberAndBranch: public HUnaryControlInstruction { +class HIsNumberAndBranch V8_FINAL : public HUnaryControlInstruction { public: explicit HIsNumberAndBranch(HValue* value) : HUnaryControlInstruction(value, NULL, NULL) { SetFlag(kFlexibleRepresentation); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -2755,27 +2799,27 @@ class HIsNumberAndBranch: public HUnaryControlInstruction { }; -class HCheckHeapObject: public HUnaryOperation { +class HCheckHeapObject V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HCheckHeapObject, HValue*); - virtual bool HasEscapingOperandAt(int index) { return false; } - virtual Representation RequiredInputRepresentation(int index) { + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; } + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } #ifdef DEBUG - virtual void Verify(); + virtual void Verify() V8_OVERRIDE; #endif - virtual HValue* Canonicalize() { + virtual HValue* Canonicalize() V8_OVERRIDE { return value()->type().IsHeapObject() ? NULL : this; } DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HCheckHeapObject(HValue* value) @@ -2807,7 +2851,7 @@ class HConstant; class HBitwise; -class InductionVariableData : public ZoneObject { +class InductionVariableData V8_FINAL : public ZoneObject { public: class InductionVariableCheck : public ZoneObject { public: @@ -3007,7 +3051,7 @@ class InductionVariableData : public ZoneObject { }; -class HPhi: public HValue { +class HPhi V8_FINAL : public HValue { public: HPhi(int merged_index, Zone* zone) : inputs_(2, zone), @@ -3023,19 +3067,22 @@ class HPhi: public HValue { SetFlag(kAllowUndefinedAsNaN); } - virtual Representation RepresentationFromInputs(); + virtual Representation RepresentationFromInputs() V8_OVERRIDE; - virtual Range* InferRange(Zone* zone); - virtual void InferRepresentation(HInferRepresentationPhase* h_infer); - virtual Representation RequiredInputRepresentation(int index) { + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; + virtual void InferRepresentation( + HInferRepresentationPhase* h_infer) V8_OVERRIDE; + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return representation(); } - virtual Representation KnownOptimalRepresentation() { + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE { return representation(); } - virtual HType CalculateInferredType(); - virtual int OperandCount() { return inputs_.length(); } - virtual HValue* OperandAt(int index) const { return inputs_[index]; } + virtual HType CalculateInferredType() V8_OVERRIDE; + virtual int OperandCount() V8_OVERRIDE { return inputs_.length(); } + virtual HValue* OperandAt(int index) const V8_OVERRIDE { + return inputs_[index]; + } HValue* GetRedundantReplacement(); void AddInput(HValue* value); bool HasRealUses(); @@ -3060,10 +3107,10 @@ class HPhi: public HValue { induction_variable_data_ = InductionVariableData::ExaminePhi(this); } - virtual void PrintTo(StringStream* stream); + virtual void PrintTo(StringStream* stream) V8_OVERRIDE; #ifdef DEBUG - virtual void Verify(); + virtual void Verify() V8_OVERRIDE; #endif void InitRealUses(int id); @@ -3100,7 +3147,7 @@ class HPhi: public HValue { ASSERT(value->IsPhi()); return reinterpret_cast<HPhi*>(value); } - virtual Opcode opcode() const { return HValue::kPhi; } + virtual Opcode opcode() const V8_OVERRIDE { return HValue::kPhi; } void SimplifyConstantInputs(); @@ -3108,8 +3155,8 @@ class HPhi: public HValue { static const int kInvalidMergedIndex = -1; protected: - virtual void DeleteFromGraph(); - virtual void InternalSetOperandAt(int index, HValue* value) { + virtual void DeleteFromGraph() V8_OVERRIDE; + virtual void InternalSetOperandAt(int index, HValue* value) V8_OVERRIDE { inputs_[index] = value; } @@ -3123,25 +3170,31 @@ class HPhi: public HValue { InductionVariableData* induction_variable_data_; // TODO(titzer): we can't eliminate the receiver for generating backtraces - virtual bool IsDeletable() const { return !IsReceiver(); } + virtual bool IsDeletable() const V8_OVERRIDE { return !IsReceiver(); } }; // Common base class for HArgumentsObject and HCapturedObject. -class HDematerializedObject: public HTemplateInstruction<0> { +class HDematerializedObject : public HInstruction { public: HDematerializedObject(int count, Zone* zone) : values_(count, zone) {} - virtual int OperandCount() { return values_.length(); } - virtual HValue* OperandAt(int index) const { return values_[index]; } + virtual int OperandCount() V8_FINAL V8_OVERRIDE { return values_.length(); } + virtual HValue* OperandAt(int index) const V8_FINAL V8_OVERRIDE { + return values_[index]; + } - virtual bool HasEscapingOperandAt(int index) { return false; } - virtual Representation RequiredInputRepresentation(int index) { + virtual bool HasEscapingOperandAt(int index) V8_FINAL V8_OVERRIDE { + return false; + } + virtual Representation RequiredInputRepresentation( + int index) V8_FINAL V8_OVERRIDE { return Representation::None(); } protected: - virtual void InternalSetOperandAt(int index, HValue* value) { + virtual void InternalSetOperandAt(int index, + HValue* value) V8_FINAL V8_OVERRIDE { values_[index] = value; } @@ -3149,11 +3202,11 @@ class HDematerializedObject: public HTemplateInstruction<0> { ZoneList<HValue*> values_; private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; } }; -class HArgumentsObject: public HDematerializedObject { +class HArgumentsObject V8_FINAL : public HDematerializedObject { public: static HArgumentsObject* New(Zone* zone, HValue* context, int count) { return new(zone) HArgumentsObject(count, zone); @@ -3180,10 +3233,10 @@ class HArgumentsObject: public HDematerializedObject { }; -class HCapturedObject: public HDematerializedObject { +class HCapturedObject V8_FINAL : public HDematerializedObject { public: - HCapturedObject(int length, Zone* zone) - : HDematerializedObject(length, zone) { + HCapturedObject(int length, int id, Zone* zone) + : HDematerializedObject(length, zone), capture_id_(id) { set_representation(Representation::Tagged()); values_.AddBlock(NULL, length, zone); // Resize list. } @@ -3193,12 +3246,28 @@ class HCapturedObject: public HDematerializedObject { // properties or elements backing store are not tracked here. const ZoneList<HValue*>* values() const { return &values_; } int length() const { return values_.length(); } + int capture_id() const { return capture_id_; } + + // Shortcut for the map value of this captured object. + HValue* map_value() const { return values()->first(); } + + void ReuseSideEffectsFromStore(HInstruction* store) { + ASSERT(store->HasObservableSideEffects()); + ASSERT(store->IsStoreNamedField()); + gvn_flags_.Add(store->gvn_flags()); + } + + // Replay effects of this instruction on the given environment. + void ReplayEnvironment(HEnvironment* env); DECLARE_CONCRETE_INSTRUCTION(CapturedObject) + + private: + int capture_id_; }; -class HConstant: public HTemplateInstruction<0> { +class HConstant V8_FINAL : public HTemplateInstruction<0> { public: DECLARE_INSTRUCTION_FACTORY_P1(HConstant, int32_t); DECLARE_INSTRUCTION_FACTORY_P2(HConstant, int32_t, Representation); @@ -3229,9 +3298,9 @@ class HConstant: public HTemplateInstruction<0> { return new_constant; } - Handle<Object> handle() { + Handle<Object> handle(Isolate* isolate) { if (handle_.is_null()) { - Factory* factory = Isolate::Current()->factory(); + Factory* factory = isolate->factory(); // Default arguments to is_not_in_new_space depend on this heap number // to be tenured so that it's guaranteed not be be located in new space. handle_ = factory->NewNumber(double_value_, TENURED); @@ -3241,10 +3310,10 @@ class HConstant: public HTemplateInstruction<0> { return handle_; } - bool InstanceOf(Handle<Map> map) { - Handle<Object> constant_object = handle(); - return constant_object->IsJSObject() && - Handle<JSObject>::cast(constant_object)->map() == *map; + bool HasMap(Handle<Map> map) { + Handle<Object> constant_object = handle(map->GetIsolate()); + return constant_object->IsHeapObject() && + Handle<HeapObject>::cast(constant_object)->map() == *map; } bool IsSpecialDouble() const { @@ -3274,35 +3343,34 @@ class HConstant: public HTemplateInstruction<0> { ASSERT(!handle_.is_null()); Heap* heap = isolate()->heap(); - ASSERT(unique_id_ != UniqueValueId(heap->minus_zero_value())); - ASSERT(unique_id_ != UniqueValueId(heap->nan_value())); - return unique_id_ == UniqueValueId(heap->undefined_value()) || - unique_id_ == UniqueValueId(heap->null_value()) || - unique_id_ == UniqueValueId(heap->true_value()) || - unique_id_ == UniqueValueId(heap->false_value()) || - unique_id_ == UniqueValueId(heap->the_hole_value()) || - unique_id_ == UniqueValueId(heap->empty_string()); + ASSERT(unique_id_ != UniqueValueId::minus_zero_value(heap)); + ASSERT(unique_id_ != UniqueValueId::nan_value(heap)); + return unique_id_ == UniqueValueId::undefined_value(heap) || + unique_id_ == UniqueValueId::null_value(heap) || + unique_id_ == UniqueValueId::true_value(heap) || + unique_id_ == UniqueValueId::false_value(heap) || + unique_id_ == UniqueValueId::the_hole_value(heap) || + unique_id_ == UniqueValueId::empty_string(heap); } bool IsCell() const { return is_cell_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } - virtual Representation KnownOptimalRepresentation() { - if (HasSmiValue() && kSmiValueSize == 31) return Representation::Smi(); + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE { + if (HasSmiValue() && SmiValuesAre31Bits()) return Representation::Smi(); if (HasInteger32Value()) return Representation::Integer32(); if (HasNumberValue()) return Representation::Double(); if (HasExternalReferenceValue()) return Representation::External(); return Representation::Tagged(); } - virtual bool EmitAtUses(); - virtual void PrintDataTo(StringStream* stream); - bool IsInteger() { return handle()->IsSmi(); } + virtual bool EmitAtUses() V8_OVERRIDE; + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; HConstant* CopyToRepresentation(Representation r, Zone* zone) const; Maybe<HConstant*> CopyToTruncatedInt32(Zone* zone); Maybe<HConstant*> CopyToTruncatedNumber(Zone* zone); @@ -3358,7 +3426,7 @@ class HConstant: public HTemplateInstruction<0> { bool HasBooleanValue() const { return type_.IsBoolean(); } bool BooleanValue() const { return boolean_value_; } - virtual intptr_t Hashcode() { + virtual intptr_t Hashcode() V8_OVERRIDE { if (has_int32_value_) { return static_cast<intptr_t>(int32_value_); } else if (has_double_value_) { @@ -3371,7 +3439,7 @@ class HConstant: public HTemplateInstruction<0> { } } - virtual void FinalizeUniqueValueId() { + virtual void FinalizeUniqueValueId() V8_OVERRIDE { if (!has_double_value_ && !has_external_reference_value_) { ASSERT(!handle_.is_null()); unique_id_ = UniqueValueId(handle_); @@ -3384,15 +3452,15 @@ class HConstant: public HTemplateInstruction<0> { } #ifdef DEBUG - virtual void Verify() { } + virtual void Verify() V8_OVERRIDE { } #endif DECLARE_CONCRETE_INSTRUCTION(Constant) protected: - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { HConstant* other_constant = HConstant::cast(other); if (has_int32_value_) { return other_constant->has_int32_value_ && @@ -3437,7 +3505,7 @@ class HConstant: public HTemplateInstruction<0> { void Initialize(Representation r); - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } // If this is a numerical constant, handle_ either points to to the // HeapObject the constant originated from or is null. If the @@ -3465,7 +3533,7 @@ class HConstant: public HTemplateInstruction<0> { }; -class HBinaryOperation: public HTemplateInstruction<3> { +class HBinaryOperation : public HTemplateInstruction<3> { public: HBinaryOperation(HValue* context, HValue* left, HValue* right, HType type = HType::Tagged()) @@ -3515,29 +3583,30 @@ class HBinaryOperation: public HTemplateInstruction<3> { observed_output_representation_ = observed; } - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { if (index == 0) return Representation::Tagged(); return observed_input_representation_[index - 1]; } virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { Representation rep = !FLAG_smi_binop && new_rep.IsSmi() ? Representation::Integer32() : new_rep; HValue::UpdateRepresentation(rep, h_infer, reason); } - virtual void InferRepresentation(HInferRepresentationPhase* h_infer); - virtual Representation RepresentationFromInputs(); + virtual void InferRepresentation( + HInferRepresentationPhase* h_infer) V8_OVERRIDE; + virtual Representation RepresentationFromInputs() V8_OVERRIDE; Representation RepresentationFromOutput(); - virtual void AssumeRepresentation(Representation r); + virtual void AssumeRepresentation(Representation r) V8_OVERRIDE; virtual bool IsCommutative() const { return false; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { if (index == 0) return Representation::Tagged(); return representation(); } @@ -3552,20 +3621,20 @@ class HBinaryOperation: public HTemplateInstruction<3> { }; -class HWrapReceiver: public HTemplateInstruction<2> { +class HWrapReceiver V8_FINAL : public HTemplateInstruction<2> { public: DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } HValue* receiver() { return OperandAt(0); } HValue* function() { return OperandAt(1); } - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(WrapReceiver) @@ -3578,7 +3647,7 @@ class HWrapReceiver: public HTemplateInstruction<2> { }; -class HApplyArguments: public HTemplateInstruction<4> { +class HApplyArguments V8_FINAL : public HTemplateInstruction<4> { public: HApplyArguments(HValue* function, HValue* receiver, @@ -3592,7 +3661,7 @@ class HApplyArguments: public HTemplateInstruction<4> { SetAllSideEffects(); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { // The length is untagged, all other inputs are tagged. return (index == 2) ? Representation::Integer32() @@ -3608,20 +3677,20 @@ class HApplyArguments: public HTemplateInstruction<4> { }; -class HArgumentsElements: public HTemplateInstruction<0> { +class HArgumentsElements V8_FINAL : public HTemplateInstruction<0> { public: DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsElements, bool); DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements) - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } bool from_inlined() const { return from_inlined_; } protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HArgumentsElements(bool from_inlined) : from_inlined_(from_inlined) { @@ -3631,24 +3700,24 @@ class HArgumentsElements: public HTemplateInstruction<0> { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } bool from_inlined_; }; -class HArgumentsLength: public HUnaryOperation { +class HArgumentsLength V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsLength, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: explicit HArgumentsLength(HValue* value) : HUnaryOperation(value) { @@ -3656,11 +3725,11 @@ class HArgumentsLength: public HUnaryOperation { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HAccessArgumentsAt: public HTemplateInstruction<3> { +class HAccessArgumentsAt V8_FINAL : public HTemplateInstruction<3> { public: HAccessArgumentsAt(HValue* arguments, HValue* length, HValue* index) { set_representation(Representation::Tagged()); @@ -3670,9 +3739,9 @@ class HAccessArgumentsAt: public HTemplateInstruction<3> { SetOperandAt(2, index); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { // The arguments elements is considered tagged. return index == 0 ? Representation::Tagged() @@ -3685,14 +3754,14 @@ class HAccessArgumentsAt: public HTemplateInstruction<3> { DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt) - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } }; class HBoundsCheckBaseIndexInformation; -class HBoundsCheck: public HTemplateInstruction<2> { +class HBoundsCheck V8_FINAL : public HTemplateInstruction<2> { public: DECLARE_INSTRUCTION_FACTORY_P2(HBoundsCheck, HValue*, HValue*); @@ -3721,27 +3790,30 @@ class HBoundsCheck: public HTemplateInstruction<2> { } } - virtual Representation RequiredInputRepresentation(int arg_index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return representation(); } - virtual void PrintDataTo(StringStream* stream); - virtual void InferRepresentation(HInferRepresentationPhase* h_infer); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; + virtual void InferRepresentation( + HInferRepresentationPhase* h_infer) V8_OVERRIDE; HValue* index() { return OperandAt(0); } HValue* length() { return OperandAt(1); } bool allow_equality() { return allow_equality_; } void set_allow_equality(bool v) { allow_equality_ = v; } - virtual int RedefinedOperandIndex() { return 0; } - virtual bool IsPurelyInformativeDefinition() { return skip_check(); } + virtual int RedefinedOperandIndex() V8_OVERRIDE { return 0; } + virtual bool IsPurelyInformativeDefinition() V8_OVERRIDE { + return skip_check(); + } DECLARE_CONCRETE_INSTRUCTION(BoundsCheck) protected: friend class HBoundsCheckBaseIndexInformation; - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } bool skip_check_; HValue* base_; int offset_; @@ -3763,13 +3835,14 @@ class HBoundsCheck: public HTemplateInstruction<2> { SetFlag(kUseGVN); } - virtual bool IsDeletable() const { + virtual bool IsDeletable() const V8_OVERRIDE { return skip_check() && !FLAG_debug_code; } }; -class HBoundsCheckBaseIndexInformation: public HTemplateInstruction<2> { +class HBoundsCheckBaseIndexInformation V8_FINAL + : public HTemplateInstruction<2> { public: explicit HBoundsCheckBaseIndexInformation(HBoundsCheck* check) { DecompositionResult decomposition; @@ -3786,18 +3859,18 @@ class HBoundsCheckBaseIndexInformation: public HTemplateInstruction<2> { DECLARE_CONCRETE_INSTRUCTION(BoundsCheckBaseIndexInformation) - virtual Representation RequiredInputRepresentation(int arg_index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return representation(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual int RedefinedOperandIndex() { return 0; } - virtual bool IsPurelyInformativeDefinition() { return true; } + virtual int RedefinedOperandIndex() V8_OVERRIDE { return 0; } + virtual bool IsPurelyInformativeDefinition() V8_OVERRIDE { return true; } }; -class HBitwiseBinaryOperation: public HBinaryOperation { +class HBitwiseBinaryOperation : public HBinaryOperation { public: HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right, HType type = HType::Tagged()) @@ -3808,7 +3881,7 @@ class HBitwiseBinaryOperation: public HBinaryOperation { SetAllSideEffects(); } - virtual void RepresentationChanged(Representation to) { + virtual void RepresentationChanged(Representation to) V8_OVERRIDE { if (!to.IsTagged()) { ASSERT(to.IsSmiOrInteger32()); ClearAllSideEffects(); @@ -3821,13 +3894,13 @@ class HBitwiseBinaryOperation: public HBinaryOperation { virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { // We only generate either int32 or generic tagged bitwise operations. if (new_rep.IsDouble()) new_rep = Representation::Integer32(); HBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); } - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { Representation r = HBinaryOperation::observed_input_representation(index); if (r.IsDouble()) return Representation::Integer32(); return r; @@ -3841,11 +3914,11 @@ class HBitwiseBinaryOperation: public HBinaryOperation { DECLARE_ABSTRACT_INSTRUCTION(BitwiseBinaryOperation) private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HMathFloorOfDiv: public HBinaryOperation { +class HMathFloorOfDiv V8_FINAL : public HBinaryOperation { public: static HMathFloorOfDiv* New(Zone* zone, HValue* context, @@ -3854,16 +3927,13 @@ class HMathFloorOfDiv: public HBinaryOperation { return new(zone) HMathFloorOfDiv(context, left, right); } - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); - - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Integer32(); - } + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: HMathFloorOfDiv(HValue* context, HValue* left, HValue* right) @@ -3877,11 +3947,11 @@ class HMathFloorOfDiv: public HBinaryOperation { SetFlag(kAllowUndefinedAsNaN); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HArithmeticBinaryOperation: public HBinaryOperation { +class HArithmeticBinaryOperation : public HBinaryOperation { public: HArithmeticBinaryOperation(HValue* context, HValue* left, HValue* right) : HBinaryOperation(context, left, right, HType::TaggedNumber()) { @@ -3890,7 +3960,7 @@ class HArithmeticBinaryOperation: public HBinaryOperation { SetFlag(kAllowUndefinedAsNaN); } - virtual void RepresentationChanged(Representation to) { + virtual void RepresentationChanged(Representation to) V8_OVERRIDE { if (to.IsTagged()) { SetAllSideEffects(); ClearFlag(kUseGVN); @@ -3903,11 +3973,11 @@ class HArithmeticBinaryOperation: public HBinaryOperation { DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation) private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HCompareGeneric: public HBinaryOperation { +class HCompareGeneric V8_FINAL : public HBinaryOperation { public: HCompareGeneric(HValue* context, HValue* left, @@ -3920,14 +3990,14 @@ class HCompareGeneric: public HBinaryOperation { SetAllSideEffects(); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return index == 0 ? Representation::Tagged() : representation(); } Token::Value token() const { return token_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(CompareGeneric) @@ -3936,7 +4006,7 @@ class HCompareGeneric: public HBinaryOperation { }; -class HCompareNumericAndBranch: public HTemplateControlInstruction<2, 2> { +class HCompareNumericAndBranch : public HTemplateControlInstruction<2, 2> { public: HCompareNumericAndBranch(HValue* left, HValue* right, Token::Value token) : token_(token) { @@ -3956,15 +4026,16 @@ class HCompareNumericAndBranch: public HTemplateControlInstruction<2, 2> { observed_input_representation_[1] = right; } - virtual void InferRepresentation(HInferRepresentationPhase* h_infer); + virtual void InferRepresentation( + HInferRepresentationPhase* h_infer) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return representation(); } - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { return observed_input_representation_[index]; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch) @@ -3974,7 +4045,8 @@ class HCompareNumericAndBranch: public HTemplateControlInstruction<2, 2> { }; -class HCompareHoleAndBranch: public HTemplateControlInstruction<2, 1> { +class HCompareHoleAndBranch V8_FINAL + : public HTemplateControlInstruction<2, 1> { public: // TODO(danno): make this private when the IfBuilder properly constructs // control flow instructions. @@ -3988,19 +4060,20 @@ class HCompareHoleAndBranch: public HTemplateControlInstruction<2, 1> { HValue* object() { return OperandAt(0); } - virtual void InferRepresentation(HInferRepresentationPhase* h_infer); + virtual void InferRepresentation( + HInferRepresentationPhase* h_infer) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return representation(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(CompareHoleAndBranch) }; -class HCompareObjectEqAndBranch: public HTemplateControlInstruction<2, 2> { +class HCompareObjectEqAndBranch : public HTemplateControlInstruction<2, 2> { public: // TODO(danno): make this private when the IfBuilder properly constructs // control flow instructions. @@ -4015,13 +4088,13 @@ class HCompareObjectEqAndBranch: public HTemplateControlInstruction<2, 2> { HValue* left() { return OperandAt(0); } HValue* right() { return OperandAt(1); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4029,24 +4102,24 @@ class HCompareObjectEqAndBranch: public HTemplateControlInstruction<2, 2> { }; -class HIsObjectAndBranch: public HUnaryControlInstruction { +class HIsObjectAndBranch V8_FINAL : public HUnaryControlInstruction { public: explicit HIsObjectAndBranch(HValue* value) : HUnaryControlInstruction(value, NULL, NULL) { } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch) }; -class HIsStringAndBranch: public HUnaryControlInstruction { +class HIsStringAndBranch V8_FINAL : public HUnaryControlInstruction { public: explicit HIsStringAndBranch(HValue* value) : HUnaryControlInstruction(value, NULL, NULL) { } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4054,28 +4127,28 @@ class HIsStringAndBranch: public HUnaryControlInstruction { }; -class HIsSmiAndBranch: public HUnaryControlInstruction { +class HIsSmiAndBranch V8_FINAL : public HUnaryControlInstruction { public: explicit HIsSmiAndBranch(HValue* value) : HUnaryControlInstruction(value, NULL, NULL) { } DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch) - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } }; -class HIsUndetectableAndBranch: public HUnaryControlInstruction { +class HIsUndetectableAndBranch V8_FINAL : public HUnaryControlInstruction { public: explicit HIsUndetectableAndBranch(HValue* value) : HUnaryControlInstruction(value, NULL, NULL) { } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4083,7 +4156,7 @@ class HIsUndetectableAndBranch: public HUnaryControlInstruction { }; -class HStringCompareAndBranch: public HTemplateControlInstruction<2, 3> { +class HStringCompareAndBranch : public HTemplateControlInstruction<2, 3> { public: HStringCompareAndBranch(HValue* context, HValue* left, @@ -4103,9 +4176,9 @@ class HStringCompareAndBranch: public HTemplateControlInstruction<2, 3> { HValue* right() { return OperandAt(2); } Token::Value token() const { return token_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4120,9 +4193,9 @@ class HStringCompareAndBranch: public HTemplateControlInstruction<2, 3> { }; -class HIsConstructCallAndBranch: public HTemplateControlInstruction<2, 0> { +class HIsConstructCallAndBranch : public HTemplateControlInstruction<2, 0> { public: - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -4130,7 +4203,7 @@ class HIsConstructCallAndBranch: public HTemplateControlInstruction<2, 0> { }; -class HHasInstanceTypeAndBranch: public HUnaryControlInstruction { +class HHasInstanceTypeAndBranch V8_FINAL : public HUnaryControlInstruction { public: HHasInstanceTypeAndBranch(HValue* value, InstanceType type) : HUnaryControlInstruction(value, NULL, NULL), from_(type), to_(type) { } @@ -4142,9 +4215,9 @@ class HHasInstanceTypeAndBranch: public HUnaryControlInstruction { InstanceType from() { return from_; } InstanceType to() { return to_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4156,12 +4229,12 @@ class HHasInstanceTypeAndBranch: public HUnaryControlInstruction { }; -class HHasCachedArrayIndexAndBranch: public HUnaryControlInstruction { +class HHasCachedArrayIndexAndBranch V8_FINAL : public HUnaryControlInstruction { public: explicit HHasCachedArrayIndexAndBranch(HValue* value) : HUnaryControlInstruction(value, NULL, NULL) { } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4169,28 +4242,28 @@ class HHasCachedArrayIndexAndBranch: public HUnaryControlInstruction { }; -class HGetCachedArrayIndex: public HUnaryOperation { +class HGetCachedArrayIndex V8_FINAL : public HUnaryOperation { public: explicit HGetCachedArrayIndex(HValue* value) : HUnaryOperation(value) { set_representation(Representation::Tagged()); SetFlag(kUseGVN); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HClassOfTestAndBranch: public HUnaryControlInstruction { +class HClassOfTestAndBranch V8_FINAL : public HUnaryControlInstruction { public: HClassOfTestAndBranch(HValue* value, Handle<String> class_name) : HUnaryControlInstruction(value, NULL, NULL), @@ -4198,11 +4271,11 @@ class HClassOfTestAndBranch: public HUnaryControlInstruction { DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch) - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; Handle<String> class_name() const { return class_name_; } @@ -4211,18 +4284,18 @@ class HClassOfTestAndBranch: public HUnaryControlInstruction { }; -class HTypeofIsAndBranch: public HUnaryControlInstruction { +class HTypeofIsAndBranch V8_FINAL : public HUnaryControlInstruction { public: HTypeofIsAndBranch(HValue* value, Handle<String> type_literal) : HUnaryControlInstruction(value, NULL, NULL), type_literal_(type_literal) { } Handle<String> type_literal() { return type_literal_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch) - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4231,7 +4304,7 @@ class HTypeofIsAndBranch: public HUnaryControlInstruction { }; -class HInstanceOf: public HBinaryOperation { +class HInstanceOf V8_FINAL : public HBinaryOperation { public: HInstanceOf(HValue* context, HValue* left, HValue* right) : HBinaryOperation(context, left, right, HType::Boolean()) { @@ -4239,17 +4312,17 @@ class HInstanceOf: public HBinaryOperation { SetAllSideEffects(); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(InstanceOf) }; -class HInstanceOfKnownGlobal: public HTemplateInstruction<2> { +class HInstanceOfKnownGlobal V8_FINAL : public HTemplateInstruction<2> { public: HInstanceOfKnownGlobal(HValue* context, HValue* left, @@ -4265,7 +4338,7 @@ class HInstanceOfKnownGlobal: public HTemplateInstruction<2> { HValue* left() { return OperandAt(1); } Handle<JSFunction> function() { return function_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4279,7 +4352,7 @@ class HInstanceOfKnownGlobal: public HTemplateInstruction<2> { // TODO(mstarzinger): This instruction should be modeled as a load of the map // field followed by a load of the instance size field once HLoadNamedField is // flexible enough to accommodate byte-field loads. -class HInstanceSize: public HTemplateInstruction<1> { +class HInstanceSize V8_FINAL : public HTemplateInstruction<1> { public: explicit HInstanceSize(HValue* object) { SetOperandAt(0, object); @@ -4288,7 +4361,7 @@ class HInstanceSize: public HTemplateInstruction<1> { HValue* object() { return OperandAt(0); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -4296,7 +4369,7 @@ class HInstanceSize: public HTemplateInstruction<1> { }; -class HPower: public HTemplateInstruction<2> { +class HPower V8_FINAL : public HTemplateInstruction<2> { public: static HInstruction* New(Zone* zone, HValue* context, @@ -4306,19 +4379,19 @@ class HPower: public HTemplateInstruction<2> { HValue* left() { return OperandAt(0); } HValue* right() const { return OperandAt(1); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return index == 0 ? Representation::Double() : Representation::None(); } - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { return RequiredInputRepresentation(index); } DECLARE_CONCRETE_INSTRUCTION(Power) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: HPower(HValue* left, HValue* right) { @@ -4329,13 +4402,13 @@ class HPower: public HTemplateInstruction<2> { SetGVNFlag(kChangesNewSpacePromotion); } - virtual bool IsDeletable() const { + virtual bool IsDeletable() const V8_OVERRIDE { return !right()->representation().IsTagged(); } }; -class HRandom: public HTemplateInstruction<1> { +class HRandom V8_FINAL : public HTemplateInstruction<1> { public: explicit HRandom(HValue* global_object) { SetOperandAt(0, global_object); @@ -4344,18 +4417,18 @@ class HRandom: public HTemplateInstruction<1> { HValue* global_object() { return OperandAt(0); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(Random) private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HAdd: public HArithmeticBinaryOperation { +class HAdd V8_FINAL : public HArithmeticBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, @@ -4364,15 +4437,16 @@ class HAdd: public HArithmeticBinaryOperation { // Add is only commutative if two integer values are added and not if two // tagged values are added (because it might be a String concatenation). - virtual bool IsCommutative() const { + virtual bool IsCommutative() const V8_OVERRIDE { return !representation().IsTagged(); } - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; - virtual bool TryDecompose(DecompositionResult* decomposition) { + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE { if (left()->IsInteger32Constant()) { decomposition->Apply(right(), left()->GetInteger32Constant()); return true; @@ -4384,7 +4458,7 @@ class HAdd: public HArithmeticBinaryOperation { } } - virtual void RepresentationChanged(Representation to) { + virtual void RepresentationChanged(Representation to) V8_OVERRIDE { if (to.IsTagged()) ClearFlag(kAllowUndefinedAsNaN); HArithmeticBinaryOperation::RepresentationChanged(to); } @@ -4392,9 +4466,9 @@ class HAdd: public HArithmeticBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Add) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; private: HAdd(HValue* context, HValue* left, HValue* right) @@ -4404,18 +4478,19 @@ class HAdd: public HArithmeticBinaryOperation { }; -class HSub: public HArithmeticBinaryOperation { +class HSub V8_FINAL : public HArithmeticBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, HValue* left, HValue* right); - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; - virtual bool TryDecompose(DecompositionResult* decomposition) { + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE { if (right()->IsInteger32Constant()) { decomposition->Apply(left(), -right()->GetInteger32Constant()); return true; @@ -4427,9 +4502,9 @@ class HSub: public HArithmeticBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Sub) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; private: HSub(HValue* context, HValue* left, HValue* right) @@ -4439,7 +4514,7 @@ class HSub: public HArithmeticBinaryOperation { }; -class HMul: public HArithmeticBinaryOperation { +class HMul V8_FINAL : public HArithmeticBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, @@ -4457,28 +4532,28 @@ class HMul: public HArithmeticBinaryOperation { return mul; } - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; // Only commutative if it is certain that not two objects are multiplicated. - virtual bool IsCommutative() const { + virtual bool IsCommutative() const V8_OVERRIDE { return !representation().IsTagged(); } virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { - if (new_rep.IsSmi()) new_rep = Representation::Integer32(); + const char* reason) V8_OVERRIDE { HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); } DECLARE_CONCRETE_INSTRUCTION(Mul) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; private: HMul(HValue* context, HValue* left, HValue* right) @@ -4488,7 +4563,7 @@ class HMul: public HArithmeticBinaryOperation { }; -class HMod: public HArithmeticBinaryOperation { +class HMod V8_FINAL : public HArithmeticBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, @@ -4508,13 +4583,14 @@ class HMod: public HArithmeticBinaryOperation { return false; } - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { if (new_rep.IsSmi()) new_rep = Representation::Integer32(); HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); } @@ -4522,9 +4598,9 @@ class HMod: public HArithmeticBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Mod) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; private: HMod(HValue* context, @@ -4541,7 +4617,7 @@ class HMod: public HArithmeticBinaryOperation { }; -class HDiv: public HArithmeticBinaryOperation { +class HDiv V8_FINAL : public HArithmeticBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, @@ -4557,13 +4633,14 @@ class HDiv: public HArithmeticBinaryOperation { return false; } - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited); + virtual HValue* EnsureAndPropagateNotMinusZero( + BitVector* visited) V8_OVERRIDE; - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { if (new_rep.IsSmi()) new_rep = Representation::Integer32(); HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); } @@ -4571,9 +4648,9 @@ class HDiv: public HArithmeticBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Div) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; private: HDiv(HValue* context, HValue* left, HValue* right) @@ -4584,7 +4661,7 @@ class HDiv: public HArithmeticBinaryOperation { }; -class HMathMinMax: public HArithmeticBinaryOperation { +class HMathMinMax V8_FINAL : public HArithmeticBinaryOperation { public: enum Operation { kMathMin, kMathMax }; @@ -4594,18 +4671,14 @@ class HMathMinMax: public HArithmeticBinaryOperation { HValue* right, Operation op); - virtual Representation RequiredInputRepresentation(int index) { - return index == 0 ? Representation::Tagged() - : representation(); - } - - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { return RequiredInputRepresentation(index); } - virtual void InferRepresentation(HInferRepresentationPhase* h_infer); + virtual void InferRepresentation( + HInferRepresentationPhase* h_infer) V8_OVERRIDE; - virtual Representation RepresentationFromInputs() { + virtual Representation RepresentationFromInputs() V8_OVERRIDE { Representation left_rep = left()->representation(); Representation right_rep = right()->representation(); Representation result = Representation::Smi(); @@ -4615,19 +4688,19 @@ class HMathMinMax: public HArithmeticBinaryOperation { return result; } - virtual bool IsCommutative() const { return true; } + virtual bool IsCommutative() const V8_OVERRIDE { return true; } Operation operation() { return operation_; } DECLARE_CONCRETE_INSTRUCTION(MathMinMax) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return other->IsMathMinMax() && HMathMinMax::cast(other)->operation_ == operation_; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; private: HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op) @@ -4638,7 +4711,7 @@ class HMathMinMax: public HArithmeticBinaryOperation { }; -class HBitwise: public HBitwiseBinaryOperation { +class HBitwise V8_FINAL : public HBitwiseBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, @@ -4648,20 +4721,20 @@ class HBitwise: public HBitwiseBinaryOperation { Token::Value op() const { return op_; } - virtual bool IsCommutative() const { return true; } + virtual bool IsCommutative() const V8_OVERRIDE { return true; } - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(Bitwise) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return op() == HBitwise::cast(other)->op(); } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; private: HBitwise(HValue* context, @@ -4681,6 +4754,7 @@ class HBitwise: public HBitwiseBinaryOperation { right->representation().IsSmi() && HConstant::cast(right)->Integer32Value() >= 0))) { SetFlag(kTruncatingToSmi); + SetFlag(kTruncatingToInt32); // BIT_OR with a smi-range negative value will always set the entire // sign-extension of the smi-sign. } else if (op == Token::BIT_OR && @@ -4691,6 +4765,7 @@ class HBitwise: public HBitwiseBinaryOperation { right->representation().IsSmi() && HConstant::cast(right)->Integer32Value() < 0))) { SetFlag(kTruncatingToSmi); + SetFlag(kTruncatingToInt32); } } @@ -4698,18 +4773,18 @@ class HBitwise: public HBitwiseBinaryOperation { }; -class HShl: public HBitwiseBinaryOperation { +class HShl V8_FINAL : public HBitwiseBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, HValue* left, HValue* right); - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { if (new_rep.IsSmi() && !(right()->IsInteger32Constant() && right()->GetInteger32Constant() >= 0)) { @@ -4721,7 +4796,7 @@ class HShl: public HBitwiseBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Shl) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: HShl(HValue* context, HValue* left, HValue* right) @@ -4729,14 +4804,14 @@ class HShl: public HBitwiseBinaryOperation { }; -class HShr: public HBitwiseBinaryOperation { +class HShr V8_FINAL : public HBitwiseBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, HValue* left, HValue* right); - virtual bool TryDecompose(DecompositionResult* decomposition) { + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE { if (right()->IsInteger32Constant()) { if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) { // This is intended to look for HAdd and HSub, to handle compounds @@ -4748,11 +4823,11 @@ class HShr: public HBitwiseBinaryOperation { return false; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { if (new_rep.IsSmi()) new_rep = Representation::Integer32(); HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); } @@ -4760,7 +4835,7 @@ class HShr: public HBitwiseBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Shr) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: HShr(HValue* context, HValue* left, HValue* right) @@ -4768,14 +4843,14 @@ class HShr: public HBitwiseBinaryOperation { }; -class HSar: public HBitwiseBinaryOperation { +class HSar V8_FINAL : public HBitwiseBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, HValue* left, HValue* right); - virtual bool TryDecompose(DecompositionResult* decomposition) { + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE { if (right()->IsInteger32Constant()) { if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) { // This is intended to look for HAdd and HSub, to handle compounds @@ -4787,11 +4862,11 @@ class HSar: public HBitwiseBinaryOperation { return false; } - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { if (new_rep.IsSmi()) new_rep = Representation::Integer32(); HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); } @@ -4799,7 +4874,7 @@ class HSar: public HBitwiseBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Sar) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: HSar(HValue* context, HValue* left, HValue* right) @@ -4807,7 +4882,7 @@ class HSar: public HBitwiseBinaryOperation { }; -class HRor: public HBitwiseBinaryOperation { +class HRor V8_FINAL : public HBitwiseBinaryOperation { public: HRor(HValue* context, HValue* left, HValue* right) : HBitwiseBinaryOperation(context, left, right) { @@ -4816,7 +4891,7 @@ class HRor: public HBitwiseBinaryOperation { virtual void UpdateRepresentation(Representation new_rep, HInferRepresentationPhase* h_infer, - const char* reason) { + const char* reason) V8_OVERRIDE { if (new_rep.IsSmi()) new_rep = Representation::Integer32(); HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); } @@ -4824,17 +4899,17 @@ class HRor: public HBitwiseBinaryOperation { DECLARE_CONCRETE_INSTRUCTION(Ror) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } }; -class HOsrEntry: public HTemplateInstruction<0> { +class HOsrEntry V8_FINAL : public HTemplateInstruction<0> { public: DECLARE_INSTRUCTION_FACTORY_P1(HOsrEntry, BailoutId); BailoutId ast_id() const { return ast_id_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -4850,7 +4925,7 @@ class HOsrEntry: public HTemplateInstruction<0> { }; -class HParameter: public HTemplateInstruction<0> { +class HParameter V8_FINAL : public HTemplateInstruction<0> { public: enum ParameterKind { STACK_PARAMETER, @@ -4865,9 +4940,9 @@ class HParameter: public HTemplateInstruction<0> { unsigned index() const { return index_; } ParameterKind kind() const { return kind_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } @@ -4894,7 +4969,7 @@ class HParameter: public HTemplateInstruction<0> { }; -class HCallStub: public HUnaryCall { +class HCallStub V8_FINAL : public HUnaryCall { public: HCallStub(HValue* context, CodeStub::Major major_key, int argument_count) : HUnaryCall(context, argument_count), @@ -4913,11 +4988,7 @@ class HCallStub: public HUnaryCall { return transcendental_type_; } - virtual void PrintDataTo(StringStream* stream); - - virtual Representation RequiredInputRepresentation(int index) { - return Representation::Tagged(); - } + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(CallStub) @@ -4927,23 +4998,22 @@ class HCallStub: public HUnaryCall { }; -class HUnknownOSRValue: public HTemplateInstruction<0> { +class HUnknownOSRValue V8_FINAL : public HTemplateInstruction<0> { public: - DECLARE_INSTRUCTION_FACTORY_P0(HUnknownOSRValue) + DECLARE_INSTRUCTION_FACTORY_P2(HUnknownOSRValue, HEnvironment*, int); - virtual Representation RequiredInputRepresentation(int index) { - return Representation::None(); - } + virtual void PrintDataTo(StringStream* stream); - void set_incoming_value(HPhi* value) { - incoming_value_ = value; + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { + return Representation::None(); } - HPhi* incoming_value() { - return incoming_value_; - } + void set_incoming_value(HPhi* value) { incoming_value_ = value; } + HPhi* incoming_value() { return incoming_value_; } + HEnvironment *environment() { return environment_; } + int index() { return index_; } - virtual Representation KnownOptimalRepresentation() { + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE { if (incoming_value_ == NULL) return Representation::None(); return incoming_value_->KnownOptimalRepresentation(); } @@ -4951,16 +5021,20 @@ class HUnknownOSRValue: public HTemplateInstruction<0> { DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue) private: - HUnknownOSRValue() - : incoming_value_(NULL) { + HUnknownOSRValue(HEnvironment* environment, int index) + : environment_(environment), + index_(index), + incoming_value_(NULL) { set_representation(Representation::Tagged()); } + HEnvironment* environment_; + int index_; HPhi* incoming_value_; }; -class HLoadGlobalCell: public HTemplateInstruction<0> { +class HLoadGlobalCell V8_FINAL : public HTemplateInstruction<0> { public: HLoadGlobalCell(Handle<Cell> cell, PropertyDetails details) : cell_(cell), details_(details), unique_id_() { @@ -4972,30 +5046,30 @@ class HLoadGlobalCell: public HTemplateInstruction<0> { Handle<Cell> cell() const { return cell_; } bool RequiresHoleCheck() const; - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual intptr_t Hashcode() { + virtual intptr_t Hashcode() V8_OVERRIDE { return unique_id_.Hashcode(); } - virtual void FinalizeUniqueValueId() { + virtual void FinalizeUniqueValueId() V8_OVERRIDE { unique_id_ = UniqueValueId(cell_); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::None(); } DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { HLoadGlobalCell* b = HLoadGlobalCell::cast(other); return unique_id_ == b->unique_id_; } private: - virtual bool IsDeletable() const { return !RequiresHoleCheck(); } + virtual bool IsDeletable() const V8_OVERRIDE { return !RequiresHoleCheck(); } Handle<Cell> cell_; PropertyDetails details_; @@ -5003,7 +5077,7 @@ class HLoadGlobalCell: public HTemplateInstruction<0> { }; -class HLoadGlobalGeneric: public HTemplateInstruction<2> { +class HLoadGlobalGeneric V8_FINAL : public HTemplateInstruction<2> { public: HLoadGlobalGeneric(HValue* context, HValue* global_object, @@ -5022,9 +5096,9 @@ class HLoadGlobalGeneric: public HTemplateInstruction<2> { Handle<Object> name() const { return name_; } bool for_typeof() const { return for_typeof_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -5036,7 +5110,7 @@ class HLoadGlobalGeneric: public HTemplateInstruction<2> { }; -class HAllocate: public HTemplateInstruction<2> { +class HAllocate V8_FINAL : public HTemplateInstruction<2> { public: static HAllocate* New(Zone* zone, HValue* context, @@ -5054,7 +5128,7 @@ class HAllocate: public HTemplateInstruction<2> { HValue* context() { return OperandAt(0); } HValue* size() { return OperandAt(1); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { if (index == 0) { return Representation::Tagged(); } else { @@ -5098,14 +5172,10 @@ class HAllocate: public HTemplateInstruction<2> { flags_ = static_cast<HAllocate::Flags>(flags_ | ALLOCATE_DOUBLE_ALIGNED); } - void UpdateSize(HValue* size) { - SetOperandAt(1, size); - } - virtual void HandleSideEffectDominator(GVNFlag side_effect, - HValue* dominator); + HValue* dominator) V8_OVERRIDE; - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(Allocate) @@ -5152,6 +5222,10 @@ class HAllocate: public HTemplateInstruction<2> { AllocationSite::CanTrack(instance_type); } + void UpdateSize(HValue* size) { + SetOperandAt(1, size); + } + HAllocate* GetFoldableDominator(HAllocate* dominator); void UpdateFreeSpaceFiller(int32_t filler_size); @@ -5175,7 +5249,33 @@ class HAllocate: public HTemplateInstruction<2> { }; -class HInnerAllocatedObject: public HTemplateInstruction<1> { +class HStoreCodeEntry V8_FINAL: public HTemplateInstruction<2> { + public: + static HStoreCodeEntry* New(Zone* zone, + HValue* context, + HValue* function, + HValue* code) { + return new(zone) HStoreCodeEntry(function, code); + } + + virtual Representation RequiredInputRepresentation(int index) { + return Representation::Tagged(); + } + + HValue* function() { return OperandAt(0); } + HValue* code_object() { return OperandAt(1); } + + DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry) + + private: + HStoreCodeEntry(HValue* function, HValue* code) { + SetOperandAt(0, function); + SetOperandAt(1, code); + } +}; + + +class HInnerAllocatedObject V8_FINAL: public HTemplateInstruction<1> { public: static HInnerAllocatedObject* New(Zone* zone, HValue* context, @@ -5188,11 +5288,11 @@ class HInnerAllocatedObject: public HTemplateInstruction<1> { HValue* base_object() { return OperandAt(0); } int offset() { return offset_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject) @@ -5239,7 +5339,7 @@ inline bool ReceiverObjectNeedsWriteBarrier(HValue* object, } -class HStoreGlobalCell: public HUnaryOperation { +class HStoreGlobalCell V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P3(HStoreGlobalCell, HValue*, Handle<PropertyCell>, PropertyDetails); @@ -5252,10 +5352,10 @@ class HStoreGlobalCell: public HUnaryOperation { return StoringValueNeedsWriteBarrier(value()); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell) @@ -5274,7 +5374,7 @@ class HStoreGlobalCell: public HUnaryOperation { }; -class HStoreGlobalGeneric: public HTemplateInstruction<3> { +class HStoreGlobalGeneric : public HTemplateInstruction<3> { public: inline static HStoreGlobalGeneric* New(Zone* zone, HValue* context, @@ -5292,9 +5392,9 @@ class HStoreGlobalGeneric: public HTemplateInstruction<3> { HValue* value() { return OperandAt(2); } StrictModeFlag strict_mode_flag() { return strict_mode_flag_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -5320,7 +5420,7 @@ class HStoreGlobalGeneric: public HTemplateInstruction<3> { }; -class HLoadContextSlot: public HUnaryOperation { +class HLoadContextSlot V8_FINAL : public HUnaryOperation { public: enum Mode { // Perform a normal load of the context slot without checking its value. @@ -5365,29 +5465,29 @@ class HLoadContextSlot: public HUnaryOperation { return mode_ != kNoCheck; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { HLoadContextSlot* b = HLoadContextSlot::cast(other); return (slot_index() == b->slot_index()); } private: - virtual bool IsDeletable() const { return !RequiresHoleCheck(); } + virtual bool IsDeletable() const V8_OVERRIDE { return !RequiresHoleCheck(); } int slot_index_; Mode mode_; }; -class HStoreContextSlot: public HTemplateInstruction<2> { +class HStoreContextSlot V8_FINAL : public HTemplateInstruction<2> { public: enum Mode { // Perform a normal store to the context slot without checking its previous @@ -5422,11 +5522,11 @@ class HStoreContextSlot: public HTemplateInstruction<2> { return mode_ != kNoCheck; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot) @@ -5445,7 +5545,7 @@ class HStoreContextSlot: public HTemplateInstruction<2> { // Represents an access to a portion of an object, such as the map pointer, // array elements pointer, etc, but not accesses to array elements themselves. -class HObjectAccess { +class HObjectAccess V8_FINAL { public: inline bool IsInobject() const { return portion() != kBackingStore && portion() != kExternalMemory; @@ -5484,6 +5584,14 @@ class HObjectAccess { return HObjectAccess(kElementsPointer, JSObject::kElementsOffset); } + static HObjectAccess ForLiteralsPointer() { + return HObjectAccess(kInobject, JSFunction::kLiteralsOffset); + } + + static HObjectAccess ForNextFunctionLinkPointer() { + return HObjectAccess(kInobject, JSFunction::kNextFunctionLinkOffset); + } + static HObjectAccess ForArrayLength(ElementsKind elements_kind) { return HObjectAccess( kArrayLengths, @@ -5528,6 +5636,35 @@ class HObjectAccess { return HObjectAccess(kInobject, JSFunction::kPrototypeOrInitialMapOffset); } + static HObjectAccess ForSharedFunctionInfoPointer() { + return HObjectAccess(kInobject, JSFunction::kSharedFunctionInfoOffset); + } + + static HObjectAccess ForCodeEntryPointer() { + return HObjectAccess(kInobject, JSFunction::kCodeEntryOffset); + } + + static HObjectAccess ForCodeOffset() { + return HObjectAccess(kInobject, SharedFunctionInfo::kCodeOffset); + } + + static HObjectAccess ForFirstCodeSlot() { + return HObjectAccess(kInobject, SharedFunctionInfo::kFirstCodeSlot); + } + + static HObjectAccess ForFirstContextSlot() { + return HObjectAccess(kInobject, SharedFunctionInfo::kFirstContextSlot); + } + + static HObjectAccess ForOptimizedCodeMap() { + return HObjectAccess(kInobject, + SharedFunctionInfo::kOptimizedCodeMapOffset); + } + + static HObjectAccess ForFunctionContextPointer() { + return HObjectAccess(kInobject, JSFunction::kContextOffset); + } + static HObjectAccess ForMap() { return HObjectAccess(kMaps, JSObject::kMapOffset); } @@ -5558,6 +5695,8 @@ class HObjectAccess { // Create an access to an in-object property in a JSArray. static HObjectAccess ForJSArrayOffset(int offset); + static HObjectAccess ForContextSlot(int index); + // Create an access to the backing store of an object. static HObjectAccess ForBackingStoreOffset(int offset, Representation representation = Representation::Tagged()); @@ -5620,52 +5759,43 @@ class HObjectAccess { }; -class HLoadNamedField: public HTemplateInstruction<2> { +class HLoadNamedField V8_FINAL : public HTemplateInstruction<1> { public: DECLARE_INSTRUCTION_FACTORY_P2(HLoadNamedField, HValue*, HObjectAccess); - DECLARE_INSTRUCTION_FACTORY_P3(HLoadNamedField, HValue*, HObjectAccess, - HValue*); HValue* object() { return OperandAt(0); } - HValue* typecheck() { - ASSERT(HasTypeCheck()); - return OperandAt(1); - } - - bool HasTypeCheck() const { return OperandAt(0) != OperandAt(1); } - void ClearTypeCheck() { SetOperandAt(1, object()); } + bool HasTypeCheck() { return object()->IsCheckMaps(); } HObjectAccess access() const { return access_; } Representation field_representation() const { return access_.representation(); } - virtual bool HasEscapingOperandAt(int index) { return false; } - virtual Representation RequiredInputRepresentation(int index) { + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; } + virtual bool HasOutOfBoundsAccess(int size) V8_OVERRIDE { + return !access().IsInobject() || access().offset() >= size; + } + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { if (index == 0 && access().IsExternalMemory()) { // object must be external in case of external memory access return Representation::External(); } return Representation::Tagged(); } - virtual Range* InferRange(Zone* zone); - virtual void PrintDataTo(StringStream* stream); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(LoadNamedField) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { HLoadNamedField* b = HLoadNamedField::cast(other); return access_.Equals(b->access_); } private: - HLoadNamedField(HValue* object, - HObjectAccess access, - HValue* typecheck = NULL) - : access_(access) { + HLoadNamedField(HValue* object, HObjectAccess access) : access_(access) { ASSERT(object != NULL); SetOperandAt(0, object); - SetOperandAt(1, typecheck != NULL ? typecheck : object); Representation representation = access.representation(); if (representation.IsSmi()) { @@ -5685,13 +5815,13 @@ class HLoadNamedField: public HTemplateInstruction<2> { access.SetGVNFlags(this, false); } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } HObjectAccess access_; }; -class HLoadNamedGeneric: public HTemplateInstruction<2> { +class HLoadNamedGeneric V8_FINAL : public HTemplateInstruction<2> { public: HLoadNamedGeneric(HValue* context, HValue* object, Handle<Object> name) : name_(name) { @@ -5705,11 +5835,11 @@ class HLoadNamedGeneric: public HTemplateInstruction<2> { HValue* object() { return OperandAt(1); } Handle<Object> name() const { return name_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric) @@ -5718,7 +5848,7 @@ class HLoadNamedGeneric: public HTemplateInstruction<2> { }; -class HLoadFunctionPrototype: public HUnaryOperation { +class HLoadFunctionPrototype V8_FINAL : public HUnaryOperation { public: explicit HLoadFunctionPrototype(HValue* function) : HUnaryOperation(function) { @@ -5729,14 +5859,14 @@ class HLoadFunctionPrototype: public HUnaryOperation { HValue* function() { return OperandAt(0); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } }; class ArrayInstructionInterface { @@ -5749,7 +5879,7 @@ class ArrayInstructionInterface { virtual ~ArrayInstructionInterface() { }; static Representation KeyedAccessIndexRequirement(Representation r) { - return r.IsInteger32() || kSmiValueSize != 31 + return r.IsInteger32() || SmiValuesAre32Bits() ? Representation::Integer32() : Representation::Smi(); } }; @@ -5761,7 +5891,7 @@ enum LoadKeyedHoleMode { }; -class HLoadKeyed +class HLoadKeyed V8_FINAL : public HTemplateInstruction<3>, public ArrayInstructionInterface { public: DECLARE_INSTRUCTION_FACTORY_P4(HLoadKeyed, HValue*, HValue*, HValue*, @@ -5796,7 +5926,7 @@ class HLoadKeyed return HoleModeField::decode(bit_field_); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { // kind_fast: tagged[int32] (none) // kind_double: tagged[int32] (none) // kind_external: external[int32] (none) @@ -5811,22 +5941,22 @@ class HLoadKeyed return Representation::None(); } - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { return RequiredInputRepresentation(index); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; bool UsesMustHandleHole() const; bool AllUsesCanTreatHoleAsNaN() const; bool RequiresHoleCheck() const; - virtual Range* InferRange(Zone* zone); + virtual Range* InferRange(Zone* zone) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(LoadKeyed) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { if (!other->IsLoadKeyed()) return false; HLoadKeyed* other_load = HLoadKeyed::cast(other); @@ -5886,7 +6016,7 @@ class HLoadKeyed SetFlag(kUseGVN); } - virtual bool IsDeletable() const { + virtual bool IsDeletable() const V8_OVERRIDE { return !RequiresHoleCheck(); } @@ -5922,7 +6052,7 @@ class HLoadKeyed }; -class HLoadKeyedGeneric: public HTemplateInstruction<3> { +class HLoadKeyedGeneric V8_FINAL : public HTemplateInstruction<3> { public: HLoadKeyedGeneric(HValue* context, HValue* obj, HValue* key) { set_representation(Representation::Tagged()); @@ -5936,28 +6066,33 @@ class HLoadKeyedGeneric: public HTemplateInstruction<3> { HValue* key() { return OperandAt(1); } HValue* context() { return OperandAt(2); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { // tagged[tagged] return Representation::Tagged(); } - virtual HValue* Canonicalize(); + virtual HValue* Canonicalize() V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric) }; -class HStoreNamedField: public HTemplateInstruction<3> { +class HStoreNamedField V8_FINAL : public HTemplateInstruction<3> { public: DECLARE_INSTRUCTION_FACTORY_P3(HStoreNamedField, HValue*, HObjectAccess, HValue*); DECLARE_CONCRETE_INSTRUCTION(StoreNamedField) - virtual bool HasEscapingOperandAt(int index) { return index == 1; } - virtual Representation RequiredInputRepresentation(int index) { + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { + return index == 1; + } + virtual bool HasOutOfBoundsAccess(int size) V8_OVERRIDE { + return !access().IsInobject() || access().offset() >= size; + } + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { if (index == 0 && access().IsExternalMemory()) { // object must be external in case of external memory access return Representation::External(); @@ -5970,11 +6105,11 @@ class HStoreNamedField: public HTemplateInstruction<3> { return Representation::Tagged(); } virtual void HandleSideEffectDominator(GVNFlag side_effect, - HValue* dominator) { + HValue* dominator) V8_OVERRIDE { ASSERT(side_effect == kChangesNewSpacePromotion); new_space_dominator_ = dominator; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; void SkipWriteBarrier() { write_barrier_mode_ = SKIP_WRITE_BARRIER; } bool IsSkipWriteBarrier() const { @@ -5991,7 +6126,8 @@ class HStoreNamedField: public HTemplateInstruction<3> { Handle<Map> transition_map() const { if (has_transition()) { - return Handle<Map>::cast(HConstant::cast(transition())->handle()); + return Handle<Map>::cast( + HConstant::cast(transition())->handle(Isolate::Current())); } else { return Handle<Map>(); } @@ -5999,7 +6135,7 @@ class HStoreNamedField: public HTemplateInstruction<3> { void SetTransition(HConstant* map_constant, CompilationInfo* info) { ASSERT(!has_transition()); // Only set once. - Handle<Map> map = Handle<Map>::cast(map_constant->handle()); + Handle<Map> map = Handle<Map>::cast(map_constant->handle(info->isolate())); if (map->CanBeDeprecated()) { map->AddDependentCompilationInfo(DependentCode::kTransitionGroup, info); } @@ -6053,7 +6189,7 @@ class HStoreNamedField: public HTemplateInstruction<3> { }; -class HStoreNamedGeneric: public HTemplateInstruction<3> { +class HStoreNamedGeneric V8_FINAL : public HTemplateInstruction<3> { public: HStoreNamedGeneric(HValue* context, HValue* object, @@ -6074,9 +6210,9 @@ class HStoreNamedGeneric: public HTemplateInstruction<3> { Handle<String> name() { return name_; } StrictModeFlag strict_mode_flag() { return strict_mode_flag_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6088,13 +6224,13 @@ class HStoreNamedGeneric: public HTemplateInstruction<3> { }; -class HStoreKeyed +class HStoreKeyed V8_FINAL : public HTemplateInstruction<3>, public ArrayInstructionInterface { public: DECLARE_INSTRUCTION_FACTORY_P4(HStoreKeyed, HValue*, HValue*, HValue*, ElementsKind); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { // kind_fast: tagged[int32] = tagged // kind_double: tagged[int32] = double // kind_smi : tagged[int32] = smi @@ -6124,7 +6260,7 @@ class HStoreKeyed return IsExternalArrayElementsKind(elements_kind()); } - virtual Representation observed_input_representation(int index) { + virtual Representation observed_input_representation(int index) V8_OVERRIDE { if (index < 2) return RequiredInputRepresentation(index); if (IsUninitialized()) { return Representation::None(); @@ -6165,7 +6301,7 @@ class HStoreKeyed } virtual void HandleSideEffectDominator(GVNFlag side_effect, - HValue* dominator) { + HValue* dominator) V8_OVERRIDE { ASSERT(side_effect == kChangesNewSpacePromotion); new_space_dominator_ = dominator; } @@ -6183,7 +6319,7 @@ class HStoreKeyed bool NeedsCanonicalization(); - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(StoreKeyed) @@ -6229,7 +6365,7 @@ class HStoreKeyed }; -class HStoreKeyedGeneric: public HTemplateInstruction<4> { +class HStoreKeyedGeneric V8_FINAL : public HTemplateInstruction<4> { public: HStoreKeyedGeneric(HValue* context, HValue* object, @@ -6250,12 +6386,12 @@ class HStoreKeyedGeneric: public HTemplateInstruction<4> { HValue* context() { return OperandAt(3); } StrictModeFlag strict_mode_flag() { return strict_mode_flag_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { // tagged[tagged] = tagged return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric) @@ -6264,7 +6400,7 @@ class HStoreKeyedGeneric: public HTemplateInstruction<4> { }; -class HTransitionElementsKind: public HTemplateInstruction<2> { +class HTransitionElementsKind V8_FINAL : public HTemplateInstruction<2> { public: inline static HTransitionElementsKind* New(Zone* zone, HValue* context, @@ -6275,7 +6411,7 @@ class HTransitionElementsKind: public HTemplateInstruction<2> { original_map, transitioned_map); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6286,9 +6422,9 @@ class HTransitionElementsKind: public HTemplateInstruction<2> { ElementsKind from_kind() { return from_kind_; } ElementsKind to_kind() { return to_kind_; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual void FinalizeUniqueValueId() { + virtual void FinalizeUniqueValueId() V8_OVERRIDE { original_map_unique_id_ = UniqueValueId(original_map_); transitioned_map_unique_id_ = UniqueValueId(transitioned_map_); } @@ -6296,7 +6432,7 @@ class HTransitionElementsKind: public HTemplateInstruction<2> { DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { HTransitionElementsKind* instr = HTransitionElementsKind::cast(other); return original_map_unique_id_ == instr->original_map_unique_id_ && transitioned_map_unique_id_ == instr->transitioned_map_unique_id_; @@ -6317,11 +6453,7 @@ class HTransitionElementsKind: public HTemplateInstruction<2> { SetOperandAt(1, context); SetFlag(kUseGVN); SetGVNFlag(kChangesElementsKind); - if (original_map->has_fast_double_elements()) { - SetGVNFlag(kChangesElementsPointer); - SetGVNFlag(kChangesNewSpacePromotion); - } - if (transitioned_map->has_fast_double_elements()) { + if (!IsSimpleMapChangeTransition(from_kind_, to_kind_)) { SetGVNFlag(kChangesElementsPointer); SetGVNFlag(kChangesNewSpacePromotion); } @@ -6337,7 +6469,7 @@ class HTransitionElementsKind: public HTemplateInstruction<2> { }; -class HStringAdd: public HBinaryOperation { +class HStringAdd V8_FINAL : public HBinaryOperation { public: static HInstruction* New(Zone* zone, HValue* context, @@ -6347,14 +6479,14 @@ class HStringAdd: public HBinaryOperation { StringAddFlags flags() const { return flags_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(StringAdd) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } private: HStringAdd(HValue* context, HValue* left, HValue* right, StringAddFlags flags) @@ -6367,13 +6499,13 @@ class HStringAdd: public HBinaryOperation { // No side-effects except possible allocation. // NOTE: this instruction _does not_ call ToString() on its inputs. - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } const StringAddFlags flags_; }; -class HStringCharCodeAt: public HTemplateInstruction<3> { +class HStringCharCodeAt V8_FINAL : public HTemplateInstruction<3> { public: static HStringCharCodeAt* New(Zone* zone, HValue* context, @@ -6396,9 +6528,9 @@ class HStringCharCodeAt: public HTemplateInstruction<3> { DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt) protected: - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } - virtual Range* InferRange(Zone* zone) { + virtual Range* InferRange(Zone* zone) V8_OVERRIDE { return new(zone) Range(0, String::kMaxUtf16CodeUnit); } @@ -6414,17 +6546,17 @@ class HStringCharCodeAt: public HTemplateInstruction<3> { } // No side effects: runtime function assumes string + number inputs. - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HStringCharFromCode: public HTemplateInstruction<2> { +class HStringCharFromCode V8_FINAL : public HTemplateInstruction<2> { public: static HInstruction* New(Zone* zone, HValue* context, HValue* char_code); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return index == 0 ? Representation::Tagged() : Representation::Integer32(); @@ -6433,7 +6565,7 @@ class HStringCharFromCode: public HTemplateInstruction<2> { HValue* context() const { return OperandAt(0); } HValue* value() const { return OperandAt(1); } - virtual bool DataEquals(HValue* other) { return true; } + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode) @@ -6447,14 +6579,14 @@ class HStringCharFromCode: public HTemplateInstruction<2> { SetGVNFlag(kChangesNewSpacePromotion); } - virtual bool IsDeletable() const { + virtual bool IsDeletable() const V8_OVERRIDE { return !value()->ToNumberCanBeObserved(); } }; template <int V> -class HMaterializedLiteral: public HTemplateInstruction<V> { +class HMaterializedLiteral : public HTemplateInstruction<V> { public: HMaterializedLiteral<V>(int index, int depth, AllocationSiteMode mode) : literal_index_(index), depth_(depth), allocation_site_mode_(mode) { @@ -6474,7 +6606,7 @@ class HMaterializedLiteral: public HTemplateInstruction<V> { } private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; } int literal_index_; int depth_; @@ -6482,7 +6614,7 @@ class HMaterializedLiteral: public HTemplateInstruction<V> { }; -class HRegExpLiteral: public HMaterializedLiteral<1> { +class HRegExpLiteral V8_FINAL : public HMaterializedLiteral<1> { public: HRegExpLiteral(HValue* context, Handle<FixedArray> literals, @@ -6503,7 +6635,7 @@ class HRegExpLiteral: public HMaterializedLiteral<1> { Handle<String> pattern() { return pattern_; } Handle<String> flags() { return flags_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6516,7 +6648,7 @@ class HRegExpLiteral: public HMaterializedLiteral<1> { }; -class HFunctionLiteral: public HTemplateInstruction<1> { +class HFunctionLiteral V8_FINAL : public HTemplateInstruction<1> { public: HFunctionLiteral(HValue* context, Handle<SharedFunctionInfo> shared, @@ -6534,7 +6666,7 @@ class HFunctionLiteral: public HTemplateInstruction<1> { HValue* context() { return OperandAt(0); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6547,7 +6679,7 @@ class HFunctionLiteral: public HTemplateInstruction<1> { LanguageMode language_mode() const { return language_mode_; } private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } Handle<SharedFunctionInfo> shared_info_; bool pretenure_ : 1; @@ -6557,7 +6689,7 @@ class HFunctionLiteral: public HTemplateInstruction<1> { }; -class HTypeof: public HTemplateInstruction<2> { +class HTypeof V8_FINAL : public HTemplateInstruction<2> { public: explicit HTypeof(HValue* context, HValue* value) { SetOperandAt(0, context); @@ -6568,24 +6700,24 @@ class HTypeof: public HTemplateInstruction<2> { HValue* context() { return OperandAt(0); } HValue* value() { return OperandAt(1); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(Typeof) private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HTrapAllocationMemento : public HTemplateInstruction<1> { +class HTrapAllocationMemento V8_FINAL : public HTemplateInstruction<1> { public: DECLARE_INSTRUCTION_FACTORY_P1(HTrapAllocationMemento, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6600,11 +6732,11 @@ class HTrapAllocationMemento : public HTemplateInstruction<1> { }; -class HToFastProperties: public HUnaryOperation { +class HToFastProperties V8_FINAL : public HUnaryOperation { public: DECLARE_INSTRUCTION_FACTORY_P1(HToFastProperties, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6626,28 +6758,28 @@ class HToFastProperties: public HUnaryOperation { #endif } - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HValueOf: public HUnaryOperation { +class HValueOf V8_FINAL : public HUnaryOperation { public: explicit HValueOf(HValue* value) : HUnaryOperation(value) { set_representation(Representation::Tagged()); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(ValueOf) private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; -class HDateField: public HUnaryOperation { +class HDateField V8_FINAL : public HUnaryOperation { public: HDateField(HValue* date, Smi* index) : HUnaryOperation(date), index_(index) { @@ -6656,7 +6788,7 @@ class HDateField: public HUnaryOperation { Smi* index() const { return index_; } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6667,7 +6799,7 @@ class HDateField: public HUnaryOperation { }; -class HSeqStringSetChar: public HTemplateInstruction<3> { +class HSeqStringSetChar V8_FINAL : public HTemplateInstruction<3> { public: HSeqStringSetChar(String::Encoding encoding, HValue* string, @@ -6684,7 +6816,7 @@ class HSeqStringSetChar: public HTemplateInstruction<3> { HValue* index() { return OperandAt(1); } HValue* value() { return OperandAt(2); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return (index == 0) ? Representation::Tagged() : Representation::Integer32(); } @@ -6696,17 +6828,17 @@ class HSeqStringSetChar: public HTemplateInstruction<3> { }; -class HCheckMapValue: public HTemplateInstruction<2> { +class HCheckMapValue V8_FINAL : public HTemplateInstruction<2> { public: DECLARE_INSTRUCTION_FACTORY_P2(HCheckMapValue, HValue*, HValue*); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual HType CalculateInferredType() { + virtual HType CalculateInferredType() V8_OVERRIDE { return HType::Tagged(); } @@ -6716,7 +6848,7 @@ class HCheckMapValue: public HTemplateInstruction<2> { DECLARE_CONCRETE_INSTRUCTION(CheckMapValue) protected: - virtual bool DataEquals(HValue* other) { + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; } @@ -6733,7 +6865,7 @@ class HCheckMapValue: public HTemplateInstruction<2> { }; -class HForInPrepareMap : public HTemplateInstruction<2> { +class HForInPrepareMap V8_FINAL : public HTemplateInstruction<2> { public: static HForInPrepareMap* New(Zone* zone, HValue* context, @@ -6741,16 +6873,16 @@ class HForInPrepareMap : public HTemplateInstruction<2> { return new(zone) HForInPrepareMap(context, object); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } HValue* context() { return OperandAt(0); } HValue* enumerable() { return OperandAt(1); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual HType CalculateInferredType() { + virtual HType CalculateInferredType() V8_OVERRIDE { return HType::Tagged(); } @@ -6767,11 +6899,11 @@ class HForInPrepareMap : public HTemplateInstruction<2> { }; -class HForInCacheArray : public HTemplateInstruction<2> { +class HForInCacheArray V8_FINAL : public HTemplateInstruction<2> { public: DECLARE_INSTRUCTION_FACTORY_P3(HForInCacheArray, HValue*, HValue*, int); - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } @@ -6787,9 +6919,9 @@ class HForInCacheArray : public HTemplateInstruction<2> { index_cache_ = index_cache; } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual HType CalculateInferredType() { + virtual HType CalculateInferredType() V8_OVERRIDE { return HType::Tagged(); } @@ -6809,7 +6941,7 @@ class HForInCacheArray : public HTemplateInstruction<2> { }; -class HLoadFieldByIndex : public HTemplateInstruction<2> { +class HLoadFieldByIndex V8_FINAL : public HTemplateInstruction<2> { public: HLoadFieldByIndex(HValue* object, HValue* index) { @@ -6818,23 +6950,23 @@ class HLoadFieldByIndex : public HTemplateInstruction<2> { set_representation(Representation::Tagged()); } - virtual Representation RequiredInputRepresentation(int index) { + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE { return Representation::Tagged(); } HValue* object() { return OperandAt(0); } HValue* index() { return OperandAt(1); } - virtual void PrintDataTo(StringStream* stream); + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE; - virtual HType CalculateInferredType() { + virtual HType CalculateInferredType() V8_OVERRIDE { return HType::Tagged(); } DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex); private: - virtual bool IsDeletable() const { return true; } + virtual bool IsDeletable() const V8_OVERRIDE { return true; } }; |