| Index: src/hydrogen-instructions.h
|
| diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h
|
| index 459121169436a9f4846f0169661c8d59dc94a36d..bef46df4ec53b5f6b78b0bccaf6781a64a05b1fc 100644
|
| --- a/src/hydrogen-instructions.h
|
| +++ b/src/hydrogen-instructions.h
|
| @@ -210,25 +210,27 @@ class LChunkBuilder;
|
| V(ExternalMemory)
|
|
|
|
|
| -#define DECLARE_ABSTRACT_INSTRUCTION(type) \
|
| - virtual bool Is##type() const FINAL OVERRIDE { 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) FINAL OVERRIDE; \
|
| - static H##type* cast(HValue* value) { \
|
| - ASSERT(value->Is##type()); \
|
| - return reinterpret_cast<H##type*>(value); \
|
| - } \
|
| - virtual Opcode opcode() const FINAL OVERRIDE { 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 FINAL : public ZoneObject {
|
| +class Range V8_FINAL : public ZoneObject {
|
| public:
|
| Range()
|
| : lower_(kMinInt),
|
| @@ -303,7 +305,7 @@ class Range FINAL : public ZoneObject {
|
| };
|
|
|
|
|
| -class UniqueValueId FINAL {
|
| +class UniqueValueId V8_FINAL {
|
| public:
|
| UniqueValueId() : raw_address_(NULL) { }
|
|
|
| @@ -345,7 +347,7 @@ class UniqueValueId FINAL {
|
| };
|
|
|
|
|
| -class HType FINAL {
|
| +class HType V8_FINAL {
|
| public:
|
| static HType None() { return HType(kNone); }
|
| static HType Tagged() { return HType(kTagged); }
|
| @@ -496,7 +498,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 FINAL BASE_EMBEDDED {
|
| +class HUseIterator V8_FINAL BASE_EMBEDDED {
|
| public:
|
| bool Done() { return current_ == NULL; }
|
| void Advance();
|
| @@ -540,7 +542,7 @@ enum GVNFlag {
|
| };
|
|
|
|
|
| -class DecompositionResult FINAL BASE_EMBEDDED {
|
| +class DecompositionResult V8_FINAL BASE_EMBEDDED {
|
| public:
|
| DecompositionResult() : base_(NULL), offset_(0), scale_(0) {}
|
|
|
| @@ -1088,7 +1090,7 @@ class HInstruction : public HValue {
|
| HInstruction* next() const { return next_; }
|
| HInstruction* previous() const { return previous_; }
|
|
|
| - virtual void PrintTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintTo(StringStream* stream) V8_OVERRIDE;
|
| virtual void PrintDataTo(StringStream* stream);
|
|
|
| bool IsLinked() const { return block() != NULL; }
|
| @@ -1110,7 +1112,7 @@ class HInstruction : public HValue {
|
| virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0;
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify() OVERRIDE;
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| virtual bool IsCall() { return false; }
|
| @@ -1126,7 +1128,7 @@ class HInstruction : public HValue {
|
| SetGVNFlag(kDependsOnOsrEntries);
|
| }
|
|
|
| - virtual void DeleteFromGraph() OVERRIDE { Unlink(); }
|
| + virtual void DeleteFromGraph() V8_OVERRIDE { Unlink(); }
|
|
|
| private:
|
| void InitializeAsFirst(HBasicBlock* block) {
|
| @@ -1147,13 +1149,15 @@ class HInstruction : public HValue {
|
| template<int V>
|
| class HTemplateInstruction : public HInstruction {
|
| public:
|
| - virtual int OperandCount() FINAL OVERRIDE { return V; }
|
| - virtual HValue* OperandAt(int i) const FINAL OVERRIDE { 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) {}
|
|
|
| - virtual void InternalSetOperandAt(int i, HValue* value) FINAL OVERRIDE {
|
| + virtual void InternalSetOperandAt(int i, HValue* value) V8_FINAL V8_OVERRIDE {
|
| inputs_[i] = value;
|
| }
|
|
|
| @@ -1168,7 +1172,7 @@ class HControlInstruction : public HInstruction {
|
| virtual int SuccessorCount() = 0;
|
| virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0;
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HBasicBlock* FirstSuccessor() {
|
| return SuccessorCount() > 0 ? SuccessorAt(0) : NULL;
|
| @@ -1181,7 +1185,7 @@ class HControlInstruction : public HInstruction {
|
| };
|
|
|
|
|
| -class HSuccessorIterator FINAL BASE_EMBEDDED {
|
| +class HSuccessorIterator V8_FINAL BASE_EMBEDDED {
|
| public:
|
| explicit HSuccessorIterator(HControlInstruction* instr)
|
| : instr_(instr), current_(0) { }
|
| @@ -1199,18 +1203,18 @@ class HSuccessorIterator FINAL BASE_EMBEDDED {
|
| template<int S, int V>
|
| class HTemplateControlInstruction : public HControlInstruction {
|
| public:
|
| - int SuccessorCount() OVERRIDE { return S; }
|
| - HBasicBlock* SuccessorAt(int i) OVERRIDE { return successors_[i]; }
|
| - void SetSuccessorAt(int i, HBasicBlock* block) OVERRIDE {
|
| + 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() OVERRIDE { return V; }
|
| - HValue* OperandAt(int i) const OVERRIDE { 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) OVERRIDE {
|
| + void InternalSetOperandAt(int i, HValue* value) V8_OVERRIDE {
|
| inputs_[i] = value;
|
| }
|
|
|
| @@ -1220,9 +1224,9 @@ class HTemplateControlInstruction : public HControlInstruction {
|
| };
|
|
|
|
|
| -class HBlockEntry FINAL : public HTemplateInstruction<0> {
|
| +class HBlockEntry V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1230,7 +1234,7 @@ class HBlockEntry FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HDummyUse FINAL : public HTemplateInstruction<1> {
|
| +class HDummyUse V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| explicit HDummyUse(HValue* value)
|
| : HTemplateInstruction<1>(HType::Smi()) {
|
| @@ -1242,23 +1246,23 @@ class HDummyUse FINAL : public HTemplateInstruction<1> {
|
|
|
| HValue* value() { return OperandAt(0); }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(DummyUse);
|
| };
|
|
|
|
|
| -class HDeoptimize FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1277,9 +1281,9 @@ class HDeoptimize FINAL : public HTemplateInstruction<0> {
|
|
|
|
|
| // Inserts an int3/stop break instruction for debugging purposes.
|
| -class HDebugBreak FINAL : public HTemplateInstruction<0> {
|
| +class HDebugBreak V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1287,17 +1291,17 @@ class HDebugBreak FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HGoto FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Goto)
|
| };
|
| @@ -1313,13 +1317,13 @@ class HUnaryControlInstruction : public HTemplateControlInstruction<2, 1> {
|
| SetSuccessorAt(1, false_target);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| };
|
|
|
|
|
| -class HBranch FINAL : public HUnaryControlInstruction {
|
| +class HBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HBranch(HValue* value,
|
| ToBooleanStub::Types expected_input_types = ToBooleanStub::Types(),
|
| @@ -1330,10 +1334,10 @@ class HBranch FINAL : public HUnaryControlInstruction {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
| - virtual Representation observed_input_representation(int index) OVERRIDE;
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE;
|
|
|
| ToBooleanStub::Types expected_input_types() const {
|
| return expected_input_types_;
|
| @@ -1346,7 +1350,7 @@ class HBranch FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HCompareMap FINAL : public HUnaryControlInstruction {
|
| +class HCompareMap V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HCompareMap(HValue* value,
|
| Handle<Map> map,
|
| @@ -1357,11 +1361,11 @@ class HCompareMap FINAL : public HUnaryControlInstruction {
|
| ASSERT(!map.is_null());
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<Map> map() const { return map_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1372,20 +1376,20 @@ class HCompareMap FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HContext FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Context)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HContext() {
|
| @@ -1393,11 +1397,11 @@ class HContext FINAL : public HTemplateInstruction<0> {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HReturn FINAL : public HTemplateControlInstruction<0, 3> {
|
| +class HReturn V8_FINAL : public HTemplateControlInstruction<0, 3> {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -1412,11 +1416,11 @@ class HReturn FINAL : public HTemplateControlInstruction<0, 3> {
|
| return new(zone) HReturn(value, context, 0);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| HValue* context() { return OperandAt(1); }
|
| @@ -1433,9 +1437,9 @@ class HReturn FINAL : public HTemplateControlInstruction<0, 3> {
|
| };
|
|
|
|
|
| -class HAbnormalExit FINAL : public HTemplateControlInstruction<0, 0> {
|
| +class HAbnormalExit V8_FINAL : public HTemplateControlInstruction<0, 0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1455,11 +1459,11 @@ class HUnaryOperation : public HTemplateInstruction<1> {
|
| }
|
|
|
| HValue* value() const { return OperandAt(0); }
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
| };
|
|
|
|
|
| -class HThrow FINAL : public HTemplateInstruction<2> {
|
| +class HThrow V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HThrow* New(Zone* zone,
|
| HValue* context,
|
| @@ -1467,7 +1471,7 @@ class HThrow FINAL : public HTemplateInstruction<2> {
|
| return new(zone) HThrow(context, value);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1485,11 +1489,11 @@ class HThrow FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HUseConst FINAL : public HUnaryOperation {
|
| +class HUseConst V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HUseConst, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1500,19 +1504,20 @@ class HUseConst FINAL : public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HForceRepresentation FINAL : 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) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation(); // Same as the output representation.
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ForceRepresentation)
|
|
|
| @@ -1524,7 +1529,7 @@ class HForceRepresentation FINAL : public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HChange FINAL : public HUnaryOperation {
|
| +class HChange V8_FINAL : public HUnaryOperation {
|
| public:
|
| HChange(HValue* value,
|
| Representation to,
|
| @@ -1550,47 +1555,48 @@ class HChange FINAL : public HUnaryOperation {
|
| return CheckUsesForFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited) OVERRIDE;
|
| - virtual HType CalculateInferredType() OVERRIDE;
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return from();
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Change)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !from().IsTagged() || value()->type().IsSmi();
|
| }
|
| };
|
|
|
|
|
| -class HClampToUint8 FINAL : public HUnaryOperation {
|
| +class HClampToUint8 V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HClampToUint8, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ClampToUint8)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HClampToUint8(HValue* value)
|
| @@ -1600,7 +1606,7 @@ class HClampToUint8 FINAL : public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| @@ -1610,7 +1616,7 @@ enum RemovableSimulate {
|
| };
|
|
|
|
|
| -class HSimulate FINAL : public HInstruction {
|
| +class HSimulate V8_FINAL : public HInstruction {
|
| public:
|
| HSimulate(BailoutId ast_id,
|
| int pop_count,
|
| @@ -1624,7 +1630,7 @@ class HSimulate FINAL : public HInstruction {
|
| removable_(removable) {}
|
| ~HSimulate() {}
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| bool HasAstId() const { return !ast_id_.IsNone(); }
|
| BailoutId ast_id() const { return ast_id_; }
|
| @@ -1654,11 +1660,13 @@ class HSimulate FINAL : public HInstruction {
|
| }
|
| return -1;
|
| }
|
| - virtual int OperandCount() OVERRIDE { return values_.length(); }
|
| - virtual HValue* OperandAt(int index) const OVERRIDE { 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) OVERRIDE { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1668,13 +1676,13 @@ class HSimulate FINAL : public HInstruction {
|
| DECLARE_CONCRETE_INSTRUCTION(Simulate)
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify() OVERRIDE;
|
| + 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) OVERRIDE {
|
| + virtual void InternalSetOperandAt(int index, HValue* value) V8_OVERRIDE {
|
| values_[index] = value;
|
| }
|
|
|
| @@ -1707,7 +1715,7 @@ class HSimulate FINAL : public HInstruction {
|
| };
|
|
|
|
|
| -class HEnvironmentMarker FINAL : public HTemplateInstruction<1> {
|
| +class HEnvironmentMarker V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| enum Kind { BIND, LOOKUP };
|
|
|
| @@ -1721,11 +1729,11 @@ class HEnvironmentMarker FINAL : public HTemplateInstruction<1> {
|
| next_simulate_ = simulate;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| #ifdef DEBUG
|
| void set_closure(Handle<JSFunction> closure) {
|
| @@ -1749,7 +1757,7 @@ class HEnvironmentMarker FINAL : public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HStackCheck FINAL : public HTemplateInstruction<1> {
|
| +class HStackCheck V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| enum Type {
|
| kFunctionEntry,
|
| @@ -1760,7 +1768,7 @@ class HStackCheck FINAL : public HTemplateInstruction<1> {
|
|
|
| HValue* context() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1799,7 +1807,7 @@ enum InliningKind {
|
| class HArgumentsObject;
|
|
|
|
|
| -class HEnterInlined FINAL : public HTemplateInstruction<0> {
|
| +class HEnterInlined V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| static HEnterInlined* New(Zone* zone,
|
| HValue* context,
|
| @@ -1818,7 +1826,7 @@ class HEnterInlined FINAL : public HTemplateInstruction<0> {
|
| void RegisterReturnTarget(HBasicBlock* return_target, Zone* zone);
|
| ZoneList<HBasicBlock*>* return_targets() { return &return_targets_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<JSFunction> closure() const { return closure_; }
|
| int arguments_count() const { return arguments_count_; }
|
| @@ -1828,7 +1836,7 @@ class HEnterInlined FINAL : public HTemplateInstruction<0> {
|
| InliningKind inlining_kind() const { return inlining_kind_; }
|
| bool undefined_receiver() const { return undefined_receiver_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1869,11 +1877,11 @@ class HEnterInlined FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HLeaveInlined FINAL : public HTemplateInstruction<0> {
|
| +class HLeaveInlined V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| HLeaveInlined() { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1881,11 +1889,11 @@ class HLeaveInlined FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HPushArgument FINAL : public HUnaryOperation {
|
| +class HPushArgument V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HPushArgument, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1900,39 +1908,39 @@ class HPushArgument FINAL : public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HThisFunction FINAL : public HTemplateInstruction<0> {
|
| +class HThisFunction V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| HThisFunction() {
|
| set_representation(Representation::Tagged());
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ThisFunction)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HOuterContext FINAL : public HUnaryOperation {
|
| +class HOuterContext V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HOuterContext, HValue*);
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(OuterContext);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HOuterContext(HValue* inner) : HUnaryOperation(inner) {
|
| @@ -1940,11 +1948,11 @@ class HOuterContext FINAL : public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HDeclareGlobals FINAL : public HUnaryOperation {
|
| +class HDeclareGlobals V8_FINAL : public HUnaryOperation {
|
| public:
|
| HDeclareGlobals(HValue* context,
|
| Handle<FixedArray> pairs,
|
| @@ -1969,7 +1977,7 @@ class HDeclareGlobals FINAL : public HUnaryOperation {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1979,7 +1987,7 @@ class HDeclareGlobals FINAL : public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HGlobalObject FINAL : public HUnaryOperation {
|
| +class HGlobalObject V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HGlobalObject(HValue* context) : HUnaryOperation(context) {
|
| set_representation(Representation::Tagged());
|
| @@ -1992,30 +2000,30 @@ class HGlobalObject FINAL : public HUnaryOperation {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(GlobalObject)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HGlobalReceiver FINAL : public HUnaryOperation {
|
| +class HGlobalReceiver V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HGlobalReceiver, HValue*);
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(GlobalReceiver)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HGlobalReceiver(HValue* global_object)
|
| @@ -2024,7 +2032,7 @@ class HGlobalReceiver FINAL : public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| @@ -2037,13 +2045,13 @@ class HCall : public HTemplateInstruction<V> {
|
| this->SetAllSideEffects();
|
| }
|
|
|
| - virtual HType CalculateInferredType() FINAL OVERRIDE {
|
| + virtual HType CalculateInferredType() V8_FINAL V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| virtual int argument_count() const { return argument_count_; }
|
|
|
| - virtual bool IsCall() FINAL OVERRIDE { return true; }
|
| + virtual bool IsCall() V8_FINAL V8_OVERRIDE { return true; }
|
|
|
| private:
|
| int argument_count_;
|
| @@ -2057,11 +2065,12 @@ class HUnaryCall : public HCall<1> {
|
| SetOperandAt(0, value);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) FINAL OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(
|
| + int index) V8_FINAL V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| };
|
| @@ -2075,9 +2084,10 @@ class HBinaryCall : public HCall<2> {
|
| SetOperandAt(1, second);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) FINAL OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(
|
| + int index) V8_FINAL V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -2086,7 +2096,7 @@ class HBinaryCall : public HCall<2> {
|
| };
|
|
|
|
|
| -class HInvokeFunction FINAL : public HBinaryCall {
|
| +class HInvokeFunction V8_FINAL : public HBinaryCall {
|
| public:
|
| HInvokeFunction(HValue* context, HValue* function, int argument_count)
|
| : HBinaryCall(context, function, argument_count) {
|
| @@ -2131,7 +2141,7 @@ class HInvokeFunction FINAL : public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallConstantFunction FINAL : public HCall<0> {
|
| +class HCallConstantFunction V8_FINAL : public HCall<0> {
|
| public:
|
| HCallConstantFunction(Handle<JSFunction> function, int argument_count)
|
| : HCall<0>(argument_count),
|
| @@ -2146,9 +2156,9 @@ class HCallConstantFunction FINAL : public HCall<0> {
|
| Isolate::Current()->builtins()->builtin(Builtins::kFunctionApply);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -2160,7 +2170,7 @@ class HCallConstantFunction FINAL : public HCall<0> {
|
| };
|
|
|
|
|
| -class HCallKeyed FINAL : public HBinaryCall {
|
| +class HCallKeyed V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallKeyed(HValue* context, HValue* key, int argument_count)
|
| : HBinaryCall(context, key, argument_count) {
|
| @@ -2173,13 +2183,13 @@ class HCallKeyed FINAL : public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallNamed FINAL : 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) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* context() { return value(); }
|
| Handle<String> name() const { return name_; }
|
| @@ -2191,7 +2201,7 @@ class HCallNamed FINAL : public HUnaryCall {
|
| };
|
|
|
|
|
| -class HCallFunction FINAL : public HBinaryCall {
|
| +class HCallFunction V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallFunction(HValue* context, HValue* function, int argument_count)
|
| : HBinaryCall(context, function, argument_count) {
|
| @@ -2211,7 +2221,7 @@ class HCallFunction FINAL : public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallGlobal FINAL : public HUnaryCall {
|
| +class HCallGlobal V8_FINAL : public HUnaryCall {
|
| public:
|
| HCallGlobal(HValue* context, Handle<String> name, int argument_count)
|
| : HUnaryCall(context, argument_count), name_(name) {
|
| @@ -2224,7 +2234,7 @@ class HCallGlobal FINAL : public HUnaryCall {
|
| return new(zone) HCallGlobal(context, name, argument_count);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* context() { return value(); }
|
| Handle<String> name() const { return name_; }
|
| @@ -2236,19 +2246,19 @@ class HCallGlobal FINAL : public HUnaryCall {
|
| };
|
|
|
|
|
| -class HCallKnownGlobal FINAL : 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) OVERRIDE;
|
| + 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -2260,7 +2270,7 @@ class HCallKnownGlobal FINAL : public HCall<0> {
|
| };
|
|
|
|
|
| -class HCallNew FINAL : public HBinaryCall {
|
| +class HCallNew V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallNew(HValue* context, HValue* constructor, int argument_count)
|
| : HBinaryCall(context, constructor, argument_count) {}
|
| @@ -2272,7 +2282,7 @@ class HCallNew FINAL : public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallNewArray FINAL : public HBinaryCall {
|
| +class HCallNewArray V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallNewArray(HValue* context, HValue* constructor, int argument_count,
|
| Handle<Cell> type_cell, ElementsKind elements_kind)
|
| @@ -2283,7 +2293,7 @@ class HCallNewArray FINAL : public HBinaryCall {
|
| HValue* context() { return first(); }
|
| HValue* constructor() { return second(); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<Cell> property_cell() const {
|
| return type_cell_;
|
| @@ -2299,7 +2309,7 @@ class HCallNewArray FINAL : public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallRuntime FINAL : public HCall<1> {
|
| +class HCallRuntime V8_FINAL : public HCall<1> {
|
| public:
|
| static HCallRuntime* New(Zone* zone,
|
| HValue* context,
|
| @@ -2309,13 +2319,13 @@ class HCallRuntime FINAL : public HCall<1> {
|
| return new(zone) HCallRuntime(context, name, c_function, argument_count);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -2335,18 +2345,18 @@ class HCallRuntime FINAL : public HCall<1> {
|
| };
|
|
|
|
|
| -class HMapEnumLength FINAL : public HUnaryOperation {
|
| +class HMapEnumLength V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HMapEnumLength, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(MapEnumLength)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HMapEnumLength(HValue* value)
|
| @@ -2356,11 +2366,11 @@ class HMapEnumLength FINAL : public HUnaryOperation {
|
| SetGVNFlag(kDependsOnMaps);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HElementsKind FINAL : public HUnaryOperation {
|
| +class HElementsKind V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HElementsKind(HValue* value) : HUnaryOperation(value) {
|
| set_representation(Representation::Integer32());
|
| @@ -2368,21 +2378,21 @@ class HElementsKind FINAL : public HUnaryOperation {
|
| SetGVNFlag(kDependsOnElementsKind);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ElementsKind)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HUnaryMathOperation FINAL : public HTemplateInstruction<2> {
|
| +class HUnaryMathOperation V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -2392,11 +2402,12 @@ class HUnaryMathOperation FINAL : public HTemplateInstruction<2> {
|
| HValue* context() { return OperandAt(0); }
|
| HValue* value() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0) {
|
| return Representation::Tagged();
|
| } else {
|
| @@ -2420,10 +2431,10 @@ class HUnaryMathOperation FINAL : public HTemplateInstruction<2> {
|
| }
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| - virtual Representation RepresentationFromInputs() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE;
|
|
|
| BuiltinFunctionId op() const { return op_; }
|
| const char* OpName() const;
|
| @@ -2431,7 +2442,7 @@ class HUnaryMathOperation FINAL : public HTemplateInstruction<2> {
|
| DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HUnaryMathOperation* b = HUnaryMathOperation::cast(other);
|
| return op_ == b->op();
|
| }
|
| @@ -2473,28 +2484,28 @@ class HUnaryMathOperation FINAL : public HTemplateInstruction<2> {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| BuiltinFunctionId op_;
|
| };
|
|
|
|
|
| -class HLoadExternalArrayPointer FINAL : public HUnaryOperation {
|
| +class HLoadExternalArrayPointer V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HLoadExternalArrayPointer, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HType CalculateInferredType() OVERRIDE {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadExternalArrayPointer)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HLoadExternalArrayPointer(HValue* value)
|
| @@ -2507,11 +2518,11 @@ class HLoadExternalArrayPointer FINAL : public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HCheckMaps FINAL : 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,
|
| @@ -2529,13 +2540,13 @@ class HCheckMaps FINAL : public HTemplateInstruction<2> {
|
|
|
| bool CanOmitMapChecks() { return omit_; }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + 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) OVERRIDE;
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + HValue* dominator) V8_OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| SmallMapList* map_set() { return &map_set_; }
|
| @@ -2544,12 +2555,12 @@ class HCheckMaps FINAL : public HTemplateInstruction<2> {
|
| return has_migration_target_;
|
| }
|
|
|
| - virtual void FinalizeUniqueValueId() OVERRIDE;
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CheckMaps)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + 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.
|
| @@ -2604,22 +2615,22 @@ class HCheckMaps FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HCheckFunction FINAL : public HUnaryOperation {
|
| +class HCheckFunction V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HCheckFunction, HValue*, Handle<JSFunction>);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify() OVERRIDE;
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| - virtual void FinalizeUniqueValueId() OVERRIDE {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| target_unique_id_ = UniqueValueId(target_);
|
| }
|
|
|
| @@ -2629,7 +2640,7 @@ class HCheckFunction FINAL : public HUnaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(CheckFunction)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HCheckFunction* b = HCheckFunction::cast(other);
|
| return target_unique_id_ == b->target_unique_id_;
|
| }
|
| @@ -2649,7 +2660,7 @@ class HCheckFunction FINAL : public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HCheckInstanceType FINAL : public HUnaryOperation {
|
| +class HCheckInstanceType V8_FINAL : public HUnaryOperation {
|
| public:
|
| static HCheckInstanceType* NewIsSpecObject(HValue* value, Zone* zone) {
|
| return new(zone) HCheckInstanceType(value, IS_SPEC_OBJECT);
|
| @@ -2665,13 +2676,13 @@ class HCheckInstanceType FINAL : public HUnaryOperation {
|
| return new(zone) HCheckInstanceType(value, IS_INTERNALIZED_STRING);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| bool is_interval_check() const { return check_ <= LAST_INTERVAL_CHECK; }
|
| void GetCheckInterval(InstanceType* first, InstanceType* last);
|
| @@ -2683,7 +2694,7 @@ class HCheckInstanceType FINAL : 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) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HCheckInstanceType* b = HCheckInstanceType::cast(other);
|
| return check_ == b->check_;
|
| }
|
| @@ -2709,15 +2720,15 @@ class HCheckInstanceType FINAL : public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HCheckSmi FINAL : public HUnaryOperation {
|
| +class HCheckSmi V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HCheckSmi, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE {
|
| + virtual HValue* Canonicalize() V8_OVERRIDE {
|
| HType value_type = value()->type();
|
| if (value_type.IsSmi()) {
|
| return NULL;
|
| @@ -2728,7 +2739,7 @@ class HCheckSmi FINAL : public HUnaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(CheckSmi)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) {
|
| @@ -2738,14 +2749,14 @@ class HCheckSmi FINAL : public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HIsNumberAndBranch FINAL : public HUnaryControlInstruction {
|
| +class HIsNumberAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsNumberAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) {
|
| SetFlag(kFlexibleRepresentation);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -2753,27 +2764,27 @@ class HIsNumberAndBranch FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HCheckHeapObject FINAL : public HUnaryOperation {
|
| +class HCheckHeapObject V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HCheckHeapObject, HValue*);
|
|
|
| - virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify() OVERRIDE;
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE {
|
| + virtual HValue* Canonicalize() V8_OVERRIDE {
|
| return value()->type().IsHeapObject() ? NULL : this;
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HCheckHeapObject(HValue* value)
|
| @@ -2805,7 +2816,7 @@ class HConstant;
|
| class HBitwise;
|
|
|
|
|
| -class InductionVariableData FINAL : public ZoneObject {
|
| +class InductionVariableData V8_FINAL : public ZoneObject {
|
| public:
|
| class InductionVariableCheck : public ZoneObject {
|
| public:
|
| @@ -3005,7 +3016,7 @@ class InductionVariableData FINAL : public ZoneObject {
|
| };
|
|
|
|
|
| -class HPhi FINAL : public HValue {
|
| +class HPhi V8_FINAL : public HValue {
|
| public:
|
| HPhi(int merged_index, Zone* zone)
|
| : inputs_(2, zone),
|
| @@ -3021,19 +3032,22 @@ class HPhi FINAL : public HValue {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual Representation RepresentationFromInputs() OVERRIDE;
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE;
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer) OVERRIDE;
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + 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() OVERRIDE {
|
| + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE {
|
| return representation();
|
| }
|
| - virtual HType CalculateInferredType() OVERRIDE;
|
| - virtual int OperandCount() OVERRIDE { return inputs_.length(); }
|
| - virtual HValue* OperandAt(int index) const OVERRIDE { 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();
|
| @@ -3058,10 +3072,10 @@ class HPhi FINAL : public HValue {
|
| induction_variable_data_ = InductionVariableData::ExaminePhi(this);
|
| }
|
|
|
| - virtual void PrintTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify() OVERRIDE;
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| void InitRealUses(int id);
|
| @@ -3098,7 +3112,7 @@ class HPhi FINAL : public HValue {
|
| ASSERT(value->IsPhi());
|
| return reinterpret_cast<HPhi*>(value);
|
| }
|
| - virtual Opcode opcode() const OVERRIDE { return HValue::kPhi; }
|
| + virtual Opcode opcode() const V8_OVERRIDE { return HValue::kPhi; }
|
|
|
| void SimplifyConstantInputs();
|
|
|
| @@ -3106,8 +3120,8 @@ class HPhi FINAL : public HValue {
|
| static const int kInvalidMergedIndex = -1;
|
|
|
| protected:
|
| - virtual void DeleteFromGraph() OVERRIDE;
|
| - virtual void InternalSetOperandAt(int index, HValue* value) OVERRIDE {
|
| + virtual void DeleteFromGraph() V8_OVERRIDE;
|
| + virtual void InternalSetOperandAt(int index, HValue* value) V8_OVERRIDE {
|
| inputs_[index] = value;
|
| }
|
|
|
| @@ -3121,7 +3135,7 @@ class HPhi FINAL : public HValue {
|
| InductionVariableData* induction_variable_data_;
|
|
|
| // TODO(titzer): we can't eliminate the receiver for generating backtraces
|
| - virtual bool IsDeletable() const OVERRIDE { return !IsReceiver(); }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return !IsReceiver(); }
|
| };
|
|
|
|
|
| @@ -3130,18 +3144,22 @@ class HDematerializedObject : public HInstruction {
|
| public:
|
| HDematerializedObject(int count, Zone* zone) : values_(count, zone) {}
|
|
|
| - virtual int OperandCount() FINAL OVERRIDE { return values_.length(); }
|
| - virtual HValue* OperandAt(int index) const FINAL OVERRIDE {
|
| + 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) FINAL OVERRIDE { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) FINAL OVERRIDE {
|
| + 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) FINAL OVERRIDE {
|
| + virtual void InternalSetOperandAt(int index,
|
| + HValue* value) V8_FINAL V8_OVERRIDE {
|
| values_[index] = value;
|
| }
|
|
|
| @@ -3149,11 +3167,11 @@ class HDematerializedObject : public HInstruction {
|
| ZoneList<HValue*> values_;
|
|
|
| private:
|
| - virtual bool IsDeletable() const FINAL OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HArgumentsObject FINAL : 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,7 +3198,7 @@ class HArgumentsObject FINAL : public HDematerializedObject {
|
| };
|
|
|
|
|
| -class HCapturedObject FINAL : public HDematerializedObject {
|
| +class HCapturedObject V8_FINAL : public HDematerializedObject {
|
| public:
|
| HCapturedObject(int length, Zone* zone)
|
| : HDematerializedObject(length, zone) {
|
| @@ -3198,7 +3216,7 @@ class HCapturedObject FINAL : public HDematerializedObject {
|
| };
|
|
|
|
|
| -class HConstant FINAL : 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);
|
| @@ -3265,11 +3283,11 @@ class HConstant FINAL : public HTemplateInstruction<0> {
|
| return is_cell_;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual Representation KnownOptimalRepresentation() OVERRIDE {
|
| + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE {
|
| if (HasSmiValue() && kSmiValueSize == 31) return Representation::Smi();
|
| if (HasInteger32Value()) return Representation::Integer32();
|
| if (HasNumberValue()) return Representation::Double();
|
| @@ -3277,8 +3295,8 @@ class HConstant FINAL : public HTemplateInstruction<0> {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual bool EmitAtUses() OVERRIDE;
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual bool EmitAtUses() V8_OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
| bool IsInteger() { return handle()->IsSmi(); }
|
| HConstant* CopyToRepresentation(Representation r, Zone* zone) const;
|
| Maybe<HConstant*> CopyToTruncatedInt32(Zone* zone);
|
| @@ -3335,7 +3353,7 @@ class HConstant FINAL : public HTemplateInstruction<0> {
|
| bool HasBooleanValue() const { return type_.IsBoolean(); }
|
| bool BooleanValue() const { return boolean_value_; }
|
|
|
| - virtual intptr_t Hashcode() OVERRIDE {
|
| + virtual intptr_t Hashcode() V8_OVERRIDE {
|
| if (has_int32_value_) {
|
| return static_cast<intptr_t>(int32_value_);
|
| } else if (has_double_value_) {
|
| @@ -3348,7 +3366,7 @@ class HConstant FINAL : public HTemplateInstruction<0> {
|
| }
|
| }
|
|
|
| - virtual void FinalizeUniqueValueId() OVERRIDE {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| if (!has_double_value_ && !has_external_reference_value_) {
|
| ASSERT(!handle_.is_null());
|
| unique_id_ = UniqueValueId(handle_);
|
| @@ -3361,15 +3379,15 @@ class HConstant FINAL : public HTemplateInstruction<0> {
|
| }
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify() OVERRIDE { }
|
| + virtual void Verify() V8_OVERRIDE { }
|
| #endif
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Constant)
|
|
|
| protected:
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HConstant* other_constant = HConstant::cast(other);
|
| if (has_int32_value_) {
|
| return other_constant->has_int32_value_ &&
|
| @@ -3412,7 +3430,7 @@ class HConstant FINAL : public HTemplateInstruction<0> {
|
|
|
| void Initialize(Representation r);
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { 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
|
| @@ -3490,29 +3508,30 @@ class HBinaryOperation : public HTemplateInstruction<3> {
|
| observed_output_representation_ = observed;
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) OVERRIDE {
|
| + 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) OVERRIDE {
|
| + 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) OVERRIDE;
|
| - virtual Representation RepresentationFromInputs() OVERRIDE;
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE;
|
| Representation RepresentationFromOutput();
|
| - virtual void AssumeRepresentation(Representation r) OVERRIDE;
|
| + virtual void AssumeRepresentation(Representation r) V8_OVERRIDE;
|
|
|
| virtual bool IsCommutative() const { return false; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0) return Representation::Tagged();
|
| return representation();
|
| }
|
| @@ -3527,20 +3546,20 @@ class HBinaryOperation : public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HWrapReceiver FINAL : public HTemplateInstruction<2> {
|
| +class HWrapReceiver V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| HValue* receiver() { return OperandAt(0); }
|
| HValue* function() { return OperandAt(1); }
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(WrapReceiver)
|
|
|
| @@ -3553,7 +3572,7 @@ class HWrapReceiver FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HApplyArguments FINAL : public HTemplateInstruction<4> {
|
| +class HApplyArguments V8_FINAL : public HTemplateInstruction<4> {
|
| public:
|
| HApplyArguments(HValue* function,
|
| HValue* receiver,
|
| @@ -3567,7 +3586,7 @@ class HApplyArguments FINAL : public HTemplateInstruction<4> {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // The length is untagged, all other inputs are tagged.
|
| return (index == 2)
|
| ? Representation::Integer32()
|
| @@ -3583,20 +3602,20 @@ class HApplyArguments FINAL : public HTemplateInstruction<4> {
|
| };
|
|
|
|
|
| -class HArgumentsElements FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| bool from_inlined() const { return from_inlined_; }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HArgumentsElements(bool from_inlined) : from_inlined_(from_inlined) {
|
| @@ -3606,24 +3625,24 @@ class HArgumentsElements FINAL : public HTemplateInstruction<0> {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| bool from_inlined_;
|
| };
|
|
|
|
|
| -class HArgumentsLength FINAL : public HUnaryOperation {
|
| +class HArgumentsLength V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsLength, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HArgumentsLength(HValue* value) : HUnaryOperation(value) {
|
| @@ -3631,11 +3650,11 @@ class HArgumentsLength FINAL : public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HAccessArgumentsAt FINAL : public HTemplateInstruction<3> {
|
| +class HAccessArgumentsAt V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HAccessArgumentsAt(HValue* arguments, HValue* length, HValue* index) {
|
| set_representation(Representation::Tagged());
|
| @@ -3645,9 +3664,9 @@ class HAccessArgumentsAt FINAL : public HTemplateInstruction<3> {
|
| SetOperandAt(2, index);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // The arguments elements is considered tagged.
|
| return index == 0
|
| ? Representation::Tagged()
|
| @@ -3660,14 +3679,14 @@ class HAccessArgumentsAt FINAL : public HTemplateInstruction<3> {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt)
|
|
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| class HBoundsCheckBaseIndexInformation;
|
|
|
|
|
| -class HBoundsCheck FINAL : public HTemplateInstruction<2> {
|
| +class HBoundsCheck V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HBoundsCheck, HValue*, HValue*);
|
|
|
| @@ -3696,27 +3715,30 @@ class HBoundsCheck FINAL : public HTemplateInstruction<2> {
|
| }
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer) OVERRIDE;
|
| + 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() OVERRIDE { return 0; }
|
| - virtual bool IsPurelyInformativeDefinition() OVERRIDE { 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) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| bool skip_check_;
|
| HValue* base_;
|
| int offset_;
|
| @@ -3738,13 +3760,14 @@ class HBoundsCheck FINAL : public HTemplateInstruction<2> {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return skip_check() && !FLAG_debug_code;
|
| }
|
| };
|
|
|
|
|
| -class HBoundsCheckBaseIndexInformation FINAL : public HTemplateInstruction<2> {
|
| +class HBoundsCheckBaseIndexInformation V8_FINAL
|
| + : public HTemplateInstruction<2> {
|
| public:
|
| explicit HBoundsCheckBaseIndexInformation(HBoundsCheck* check) {
|
| DecompositionResult decomposition;
|
| @@ -3761,14 +3784,14 @@ class HBoundsCheckBaseIndexInformation FINAL : public HTemplateInstruction<2> {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(BoundsCheckBaseIndexInformation)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual int RedefinedOperandIndex() OVERRIDE { return 0; }
|
| - virtual bool IsPurelyInformativeDefinition() OVERRIDE { return true; }
|
| + virtual int RedefinedOperandIndex() V8_OVERRIDE { return 0; }
|
| + virtual bool IsPurelyInformativeDefinition() V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| @@ -3783,7 +3806,7 @@ class HBitwiseBinaryOperation : public HBinaryOperation {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual void RepresentationChanged(Representation to) OVERRIDE {
|
| + virtual void RepresentationChanged(Representation to) V8_OVERRIDE {
|
| if (!to.IsTagged()) {
|
| ASSERT(to.IsSmiOrInteger32());
|
| ClearAllSideEffects();
|
| @@ -3796,13 +3819,13 @@ class HBitwiseBinaryOperation : public HBinaryOperation {
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + 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) OVERRIDE {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| Representation r = HBinaryOperation::observed_input_representation(index);
|
| if (r.IsDouble()) return Representation::Integer32();
|
| return r;
|
| @@ -3816,11 +3839,11 @@ class HBitwiseBinaryOperation : public HBinaryOperation {
|
| DECLARE_ABSTRACT_INSTRUCTION(BitwiseBinaryOperation)
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HMathFloorOfDiv FINAL : public HBinaryOperation {
|
| +class HMathFloorOfDiv V8_FINAL : public HBinaryOperation {
|
| public:
|
| static HMathFloorOfDiv* New(Zone* zone,
|
| HValue* context,
|
| @@ -3829,12 +3852,13 @@ class HMathFloorOfDiv FINAL : public HBinaryOperation {
|
| return new(zone) HMathFloorOfDiv(context, left, right);
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HMathFloorOfDiv(HValue* context, HValue* left, HValue* right)
|
| @@ -3848,7 +3872,7 @@ class HMathFloorOfDiv FINAL : public HBinaryOperation {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| @@ -3861,7 +3885,7 @@ class HArithmeticBinaryOperation : public HBinaryOperation {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual void RepresentationChanged(Representation to) OVERRIDE {
|
| + virtual void RepresentationChanged(Representation to) V8_OVERRIDE {
|
| if (to.IsTagged()) {
|
| SetAllSideEffects();
|
| ClearFlag(kUseGVN);
|
| @@ -3874,11 +3898,11 @@ class HArithmeticBinaryOperation : public HBinaryOperation {
|
| DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation)
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HCompareGeneric FINAL : public HBinaryOperation {
|
| +class HCompareGeneric V8_FINAL : public HBinaryOperation {
|
| public:
|
| HCompareGeneric(HValue* context,
|
| HValue* left,
|
| @@ -3891,14 +3915,14 @@ class HCompareGeneric FINAL : public HBinaryOperation {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return index == 0
|
| ? Representation::Tagged()
|
| : representation();
|
| }
|
|
|
| Token::Value token() const { return token_; }
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
|
|
|
| @@ -3927,15 +3951,16 @@ class HCompareNumericAndBranch : public HTemplateControlInstruction<2, 2> {
|
| observed_input_representation_[1] = right;
|
| }
|
|
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer) OVERRIDE;
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
| - virtual Representation observed_input_representation(int index) OVERRIDE {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return observed_input_representation_[index];
|
| }
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch)
|
|
|
| @@ -3945,7 +3970,8 @@ class HCompareNumericAndBranch : public HTemplateControlInstruction<2, 2> {
|
| };
|
|
|
|
|
| -class HCompareHoleAndBranch FINAL : 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.
|
| @@ -3959,13 +3985,14 @@ class HCompareHoleAndBranch FINAL : public HTemplateControlInstruction<2, 1> {
|
|
|
| HValue* object() { return OperandAt(0); }
|
|
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer) OVERRIDE;
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CompareHoleAndBranch)
|
| };
|
| @@ -3986,13 +4013,13 @@ class HCompareObjectEqAndBranch : public HTemplateControlInstruction<2, 2> {
|
| HValue* left() { return OperandAt(0); }
|
| HValue* right() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) OVERRIDE {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4000,24 +4027,24 @@ class HCompareObjectEqAndBranch : public HTemplateControlInstruction<2, 2> {
|
| };
|
|
|
|
|
| -class HIsObjectAndBranch FINAL : public HUnaryControlInstruction {
|
| +class HIsObjectAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsObjectAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch)
|
| };
|
|
|
| -class HIsStringAndBranch FINAL : public HUnaryControlInstruction {
|
| +class HIsStringAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsStringAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4025,28 +4052,28 @@ class HIsStringAndBranch FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HIsSmiAndBranch FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HIsUndetectableAndBranch FINAL : public HUnaryControlInstruction {
|
| +class HIsUndetectableAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsUndetectableAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4074,9 +4101,9 @@ class HStringCompareAndBranch : public HTemplateControlInstruction<2, 3> {
|
| HValue* right() { return OperandAt(2); }
|
| Token::Value token() const { return token_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4093,7 +4120,7 @@ class HStringCompareAndBranch : public HTemplateControlInstruction<2, 3> {
|
|
|
| class HIsConstructCallAndBranch : public HTemplateControlInstruction<2, 0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4101,7 +4128,7 @@ class HIsConstructCallAndBranch : public HTemplateControlInstruction<2, 0> {
|
| };
|
|
|
|
|
| -class HHasInstanceTypeAndBranch FINAL : public HUnaryControlInstruction {
|
| +class HHasInstanceTypeAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HHasInstanceTypeAndBranch(HValue* value, InstanceType type)
|
| : HUnaryControlInstruction(value, NULL, NULL), from_(type), to_(type) { }
|
| @@ -4113,9 +4140,9 @@ class HHasInstanceTypeAndBranch FINAL : public HUnaryControlInstruction {
|
| InstanceType from() { return from_; }
|
| InstanceType to() { return to_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4127,12 +4154,12 @@ class HHasInstanceTypeAndBranch FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HHasCachedArrayIndexAndBranch FINAL : public HUnaryControlInstruction {
|
| +class HHasCachedArrayIndexAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HHasCachedArrayIndexAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4140,28 +4167,28 @@ class HHasCachedArrayIndexAndBranch FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HGetCachedArrayIndex FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HClassOfTestAndBranch FINAL : public HUnaryControlInstruction {
|
| +class HClassOfTestAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HClassOfTestAndBranch(HValue* value, Handle<String> class_name)
|
| : HUnaryControlInstruction(value, NULL, NULL),
|
| @@ -4169,11 +4196,11 @@ class HClassOfTestAndBranch FINAL : public HUnaryControlInstruction {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<String> class_name() const { return class_name_; }
|
|
|
| @@ -4182,18 +4209,18 @@ class HClassOfTestAndBranch FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HTypeofIsAndBranch FINAL : 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) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4202,7 +4229,7 @@ class HTypeofIsAndBranch FINAL : public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HInstanceOf FINAL : public HBinaryOperation {
|
| +class HInstanceOf V8_FINAL : public HBinaryOperation {
|
| public:
|
| HInstanceOf(HValue* context, HValue* left, HValue* right)
|
| : HBinaryOperation(context, left, right, HType::Boolean()) {
|
| @@ -4210,17 +4237,17 @@ class HInstanceOf FINAL : public HBinaryOperation {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(InstanceOf)
|
| };
|
|
|
|
|
| -class HInstanceOfKnownGlobal FINAL : public HTemplateInstruction<2> {
|
| +class HInstanceOfKnownGlobal V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HInstanceOfKnownGlobal(HValue* context,
|
| HValue* left,
|
| @@ -4236,7 +4263,7 @@ class HInstanceOfKnownGlobal FINAL : public HTemplateInstruction<2> {
|
| HValue* left() { return OperandAt(1); }
|
| Handle<JSFunction> function() { return function_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4250,7 +4277,7 @@ class HInstanceOfKnownGlobal FINAL : 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 FINAL : public HTemplateInstruction<1> {
|
| +class HInstanceSize V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| explicit HInstanceSize(HValue* object) {
|
| SetOperandAt(0, object);
|
| @@ -4259,7 +4286,7 @@ class HInstanceSize FINAL : public HTemplateInstruction<1> {
|
|
|
| HValue* object() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4267,7 +4294,7 @@ class HInstanceSize FINAL : public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HPower FINAL : public HTemplateInstruction<2> {
|
| +class HPower V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4277,19 +4304,19 @@ class HPower FINAL : public HTemplateInstruction<2> {
|
| HValue* left() { return OperandAt(0); }
|
| HValue* right() const { return OperandAt(1); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return index == 0
|
| ? Representation::Double()
|
| : Representation::None();
|
| }
|
| - virtual Representation observed_input_representation(int index) OVERRIDE {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return RequiredInputRepresentation(index);
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Power)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HPower(HValue* left, HValue* right) {
|
| @@ -4300,13 +4327,13 @@ class HPower FINAL : public HTemplateInstruction<2> {
|
| SetGVNFlag(kChangesNewSpacePromotion);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !right()->representation().IsTagged();
|
| }
|
| };
|
|
|
|
|
| -class HRandom FINAL : public HTemplateInstruction<1> {
|
| +class HRandom V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| explicit HRandom(HValue* global_object) {
|
| SetOperandAt(0, global_object);
|
| @@ -4315,18 +4342,18 @@ class HRandom FINAL : public HTemplateInstruction<1> {
|
|
|
| HValue* global_object() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Random)
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HAdd FINAL : public HArithmeticBinaryOperation {
|
| +class HAdd V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4335,15 +4362,16 @@ class HAdd FINAL : 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 OVERRIDE {
|
| + virtual bool IsCommutative() const V8_OVERRIDE {
|
| return !representation().IsTagged();
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
|
| + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE {
|
| if (left()->IsInteger32Constant()) {
|
| decomposition->Apply(right(), left()->GetInteger32Constant());
|
| return true;
|
| @@ -4355,7 +4383,7 @@ class HAdd FINAL : public HArithmeticBinaryOperation {
|
| }
|
| }
|
|
|
| - virtual void RepresentationChanged(Representation to) OVERRIDE {
|
| + virtual void RepresentationChanged(Representation to) V8_OVERRIDE {
|
| if (to.IsTagged()) ClearFlag(kAllowUndefinedAsNaN);
|
| HArithmeticBinaryOperation::RepresentationChanged(to);
|
| }
|
| @@ -4363,9 +4391,9 @@ class HAdd FINAL : public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Add)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HAdd(HValue* context, HValue* left, HValue* right)
|
| @@ -4375,18 +4403,19 @@ class HAdd FINAL : public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HSub FINAL : 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) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
|
| + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE {
|
| if (right()->IsInteger32Constant()) {
|
| decomposition->Apply(left(), -right()->GetInteger32Constant());
|
| return true;
|
| @@ -4398,9 +4427,9 @@ class HSub FINAL : public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Sub)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HSub(HValue* context, HValue* left, HValue* right)
|
| @@ -4410,7 +4439,7 @@ class HSub FINAL : public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HMul FINAL : public HArithmeticBinaryOperation {
|
| +class HMul V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4428,18 +4457,19 @@ class HMul FINAL : public HArithmeticBinaryOperation {
|
| return mul;
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| // Only commutative if it is certain that not two objects are multiplicated.
|
| - virtual bool IsCommutative() const OVERRIDE {
|
| + virtual bool IsCommutative() const V8_OVERRIDE {
|
| return !representation().IsTagged();
|
| }
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4447,9 +4477,9 @@ class HMul FINAL : public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Mul)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HMul(HValue* context, HValue* left, HValue* right)
|
| @@ -4459,7 +4489,7 @@ class HMul FINAL : public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HMod FINAL : public HArithmeticBinaryOperation {
|
| +class HMod V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4479,13 +4509,14 @@ class HMod FINAL : public HArithmeticBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4493,9 +4524,9 @@ class HMod FINAL : public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Mod)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HMod(HValue* context,
|
| @@ -4512,7 +4543,7 @@ class HMod FINAL : public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HDiv FINAL : public HArithmeticBinaryOperation {
|
| +class HDiv V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4528,13 +4559,14 @@ class HDiv FINAL : public HArithmeticBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited) OVERRIDE;
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4542,9 +4574,9 @@ class HDiv FINAL : public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Div)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HDiv(HValue* context, HValue* left, HValue* right)
|
| @@ -4555,7 +4587,7 @@ class HDiv FINAL : public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HMathMinMax FINAL : public HArithmeticBinaryOperation {
|
| +class HMathMinMax V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| enum Operation { kMathMin, kMathMax };
|
|
|
| @@ -4565,13 +4597,14 @@ class HMathMinMax FINAL : public HArithmeticBinaryOperation {
|
| HValue* right,
|
| Operation op);
|
|
|
| - virtual Representation observed_input_representation(int index) OVERRIDE {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return RequiredInputRepresentation(index);
|
| }
|
|
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer) OVERRIDE;
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
|
|
| - virtual Representation RepresentationFromInputs() OVERRIDE {
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE {
|
| Representation left_rep = left()->representation();
|
| Representation right_rep = right()->representation();
|
| Representation result = Representation::Smi();
|
| @@ -4581,19 +4614,19 @@ class HMathMinMax FINAL : public HArithmeticBinaryOperation {
|
| return result;
|
| }
|
|
|
| - virtual bool IsCommutative() const OVERRIDE { return true; }
|
| + virtual bool IsCommutative() const V8_OVERRIDE { return true; }
|
|
|
| Operation operation() { return operation_; }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(MathMinMax)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| return other->IsMathMinMax() &&
|
| HMathMinMax::cast(other)->operation_ == operation_;
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op)
|
| @@ -4604,7 +4637,7 @@ class HMathMinMax FINAL : public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HBitwise FINAL : public HBitwiseBinaryOperation {
|
| +class HBitwise V8_FINAL : public HBitwiseBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4614,20 +4647,20 @@ class HBitwise FINAL : public HBitwiseBinaryOperation {
|
|
|
| Token::Value op() const { return op_; }
|
|
|
| - virtual bool IsCommutative() const OVERRIDE { return true; }
|
| + virtual bool IsCommutative() const V8_OVERRIDE { return true; }
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Bitwise)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| return op() == HBitwise::cast(other)->op();
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HBitwise(HValue* context,
|
| @@ -4664,18 +4697,18 @@ class HBitwise FINAL : public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HShl FINAL : 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) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi() &&
|
| !(right()->IsInteger32Constant() &&
|
| right()->GetInteger32Constant() >= 0)) {
|
| @@ -4687,7 +4720,7 @@ class HShl FINAL : public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Shl)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HShl(HValue* context, HValue* left, HValue* right)
|
| @@ -4695,14 +4728,14 @@ class HShl FINAL : public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HShr FINAL : 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) OVERRIDE {
|
| + 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
|
| @@ -4714,11 +4747,11 @@ class HShr FINAL : public HBitwiseBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4726,7 +4759,7 @@ class HShr FINAL : public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Shr)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HShr(HValue* context, HValue* left, HValue* right)
|
| @@ -4734,14 +4767,14 @@ class HShr FINAL : public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HSar FINAL : 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) OVERRIDE {
|
| + 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
|
| @@ -4753,11 +4786,11 @@ class HSar FINAL : public HBitwiseBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4765,7 +4798,7 @@ class HSar FINAL : public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Sar)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HSar(HValue* context, HValue* left, HValue* right)
|
| @@ -4773,7 +4806,7 @@ class HSar FINAL : public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HRor FINAL : public HBitwiseBinaryOperation {
|
| +class HRor V8_FINAL : public HBitwiseBinaryOperation {
|
| public:
|
| HRor(HValue* context, HValue* left, HValue* right)
|
| : HBitwiseBinaryOperation(context, left, right) {
|
| @@ -4782,7 +4815,7 @@ class HRor FINAL : public HBitwiseBinaryOperation {
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) OVERRIDE {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4790,17 +4823,17 @@ class HRor FINAL : public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Ror)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HOsrEntry FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4816,7 +4849,7 @@ class HOsrEntry FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HParameter FINAL : public HTemplateInstruction<0> {
|
| +class HParameter V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| enum ParameterKind {
|
| STACK_PARAMETER,
|
| @@ -4831,9 +4864,9 @@ class HParameter FINAL : public HTemplateInstruction<0> {
|
| unsigned index() const { return index_; }
|
| ParameterKind kind() const { return kind_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4860,7 +4893,7 @@ class HParameter FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HCallStub FINAL : public HUnaryCall {
|
| +class HCallStub V8_FINAL : public HUnaryCall {
|
| public:
|
| HCallStub(HValue* context, CodeStub::Major major_key, int argument_count)
|
| : HUnaryCall(context, argument_count),
|
| @@ -4879,7 +4912,7 @@ class HCallStub FINAL : public HUnaryCall {
|
| return transcendental_type_;
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CallStub)
|
|
|
| @@ -4889,11 +4922,11 @@ class HCallStub FINAL : public HUnaryCall {
|
| };
|
|
|
|
|
| -class HUnknownOSRValue FINAL : public HTemplateInstruction<0> {
|
| +class HUnknownOSRValue V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P0(HUnknownOSRValue)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4905,7 +4938,7 @@ class HUnknownOSRValue FINAL : public HTemplateInstruction<0> {
|
| return incoming_value_;
|
| }
|
|
|
| - virtual Representation KnownOptimalRepresentation() OVERRIDE {
|
| + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE {
|
| if (incoming_value_ == NULL) return Representation::None();
|
| return incoming_value_->KnownOptimalRepresentation();
|
| }
|
| @@ -4922,7 +4955,7 @@ class HUnknownOSRValue FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HLoadGlobalCell FINAL : public HTemplateInstruction<0> {
|
| +class HLoadGlobalCell V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| HLoadGlobalCell(Handle<Cell> cell, PropertyDetails details)
|
| : cell_(cell), details_(details), unique_id_() {
|
| @@ -4934,30 +4967,30 @@ class HLoadGlobalCell FINAL : public HTemplateInstruction<0> {
|
| Handle<Cell> cell() const { return cell_; }
|
| bool RequiresHoleCheck() const;
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual intptr_t Hashcode() OVERRIDE {
|
| + virtual intptr_t Hashcode() V8_OVERRIDE {
|
| return unique_id_.Hashcode();
|
| }
|
|
|
| - virtual void FinalizeUniqueValueId() OVERRIDE {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| unique_id_ = UniqueValueId(cell_);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HLoadGlobalCell* b = HLoadGlobalCell::cast(other);
|
| return unique_id_ == b->unique_id_;
|
| }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return !RequiresHoleCheck(); }
|
|
|
| Handle<Cell> cell_;
|
| PropertyDetails details_;
|
| @@ -4965,7 +4998,7 @@ class HLoadGlobalCell FINAL : public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HLoadGlobalGeneric FINAL : public HTemplateInstruction<2> {
|
| +class HLoadGlobalGeneric V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HLoadGlobalGeneric(HValue* context,
|
| HValue* global_object,
|
| @@ -4984,9 +5017,9 @@ class HLoadGlobalGeneric FINAL : public HTemplateInstruction<2> {
|
| Handle<Object> name() const { return name_; }
|
| bool for_typeof() const { return for_typeof_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4998,7 +5031,7 @@ class HLoadGlobalGeneric FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HAllocate FINAL : public HTemplateInstruction<2> {
|
| +class HAllocate V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HAllocate* New(Zone* zone,
|
| HValue* context,
|
| @@ -5016,7 +5049,7 @@ class HAllocate FINAL : public HTemplateInstruction<2> {
|
| HValue* context() { return OperandAt(0); }
|
| HValue* size() { return OperandAt(1); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0) {
|
| return Representation::Tagged();
|
| } else {
|
| @@ -5065,9 +5098,9 @@ class HAllocate FINAL : public HTemplateInstruction<2> {
|
| }
|
|
|
| virtual void HandleSideEffectDominator(GVNFlag side_effect,
|
| - HValue* dominator) OVERRIDE;
|
| + HValue* dominator) V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Allocate)
|
|
|
| @@ -5107,7 +5140,7 @@ class HAllocate FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HInnerAllocatedObject FINAL : public HTemplateInstruction<1> {
|
| +class HInnerAllocatedObject V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| static HInnerAllocatedObject* New(Zone* zone,
|
| HValue* context,
|
| @@ -5120,11 +5153,11 @@ class HInnerAllocatedObject FINAL : public HTemplateInstruction<1> {
|
| HValue* base_object() { return OperandAt(0); }
|
| int offset() { return offset_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject)
|
|
|
| @@ -5171,7 +5204,7 @@ inline bool ReceiverObjectNeedsWriteBarrier(HValue* object,
|
| }
|
|
|
|
|
| -class HStoreGlobalCell FINAL : public HUnaryOperation {
|
| +class HStoreGlobalCell V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P3(HStoreGlobalCell, HValue*,
|
| Handle<PropertyCell>, PropertyDetails);
|
| @@ -5184,10 +5217,10 @@ class HStoreGlobalCell FINAL : public HUnaryOperation {
|
| return StoringValueNeedsWriteBarrier(value());
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell)
|
|
|
| @@ -5224,9 +5257,9 @@ class HStoreGlobalGeneric : public HTemplateInstruction<3> {
|
| HValue* value() { return OperandAt(2); }
|
| StrictModeFlag strict_mode_flag() { return strict_mode_flag_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -5252,7 +5285,7 @@ class HStoreGlobalGeneric : public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HLoadContextSlot FINAL : public HUnaryOperation {
|
| +class HLoadContextSlot V8_FINAL : public HUnaryOperation {
|
| public:
|
| enum Mode {
|
| // Perform a normal load of the context slot without checking its value.
|
| @@ -5297,29 +5330,29 @@ class HLoadContextSlot FINAL : public HUnaryOperation {
|
| return mode_ != kNoCheck;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HLoadContextSlot* b = HLoadContextSlot::cast(other);
|
| return (slot_index() == b->slot_index());
|
| }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return !RequiresHoleCheck(); }
|
|
|
| int slot_index_;
|
| Mode mode_;
|
| };
|
|
|
|
|
| -class HStoreContextSlot FINAL : 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
|
| @@ -5354,11 +5387,11 @@ class HStoreContextSlot FINAL : public HTemplateInstruction<2> {
|
| return mode_ != kNoCheck;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot)
|
|
|
| @@ -5377,7 +5410,7 @@ class HStoreContextSlot FINAL : 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 FINAL {
|
| +class HObjectAccess V8_FINAL {
|
| public:
|
| inline bool IsInobject() const {
|
| return portion() != kBackingStore && portion() != kExternalMemory;
|
| @@ -5552,7 +5585,7 @@ class HObjectAccess FINAL {
|
| };
|
|
|
|
|
| -class HLoadNamedField FINAL : public HTemplateInstruction<2> {
|
| +class HLoadNamedField V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HLoadNamedField, HValue*, HObjectAccess);
|
| DECLARE_INSTRUCTION_FACTORY_P3(HLoadNamedField, HValue*, HObjectAccess,
|
| @@ -5571,21 +5604,21 @@ class HLoadNamedField FINAL : public HTemplateInstruction<2> {
|
| return access_.representation();
|
| }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + 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) OVERRIDE;
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadNamedField)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HLoadNamedField* b = HLoadNamedField::cast(other);
|
| return access_.Equals(b->access_);
|
| }
|
| @@ -5617,13 +5650,13 @@ class HLoadNamedField FINAL : public HTemplateInstruction<2> {
|
| access.SetGVNFlags(this, false);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| HObjectAccess access_;
|
| };
|
|
|
|
|
| -class HLoadNamedGeneric FINAL : public HTemplateInstruction<2> {
|
| +class HLoadNamedGeneric V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HLoadNamedGeneric(HValue* context, HValue* object, Handle<Object> name)
|
| : name_(name) {
|
| @@ -5637,11 +5670,11 @@ class HLoadNamedGeneric FINAL : public HTemplateInstruction<2> {
|
| HValue* object() { return OperandAt(1); }
|
| Handle<Object> name() const { return name_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric)
|
|
|
| @@ -5650,7 +5683,7 @@ class HLoadNamedGeneric FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HLoadFunctionPrototype FINAL : public HUnaryOperation {
|
| +class HLoadFunctionPrototype V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HLoadFunctionPrototype(HValue* function)
|
| : HUnaryOperation(function) {
|
| @@ -5661,14 +5694,14 @@ class HLoadFunctionPrototype FINAL : public HUnaryOperation {
|
|
|
| HValue* function() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
| class ArrayInstructionInterface {
|
| @@ -5693,7 +5726,7 @@ enum LoadKeyedHoleMode {
|
| };
|
|
|
|
|
| -class HLoadKeyed FINAL
|
| +class HLoadKeyed V8_FINAL
|
| : public HTemplateInstruction<3>, public ArrayInstructionInterface {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P4(HLoadKeyed, HValue*, HValue*, HValue*,
|
| @@ -5728,7 +5761,7 @@ class HLoadKeyed FINAL
|
| return HoleModeField::decode(bit_field_);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // kind_fast: tagged[int32] (none)
|
| // kind_double: tagged[int32] (none)
|
| // kind_external: external[int32] (none)
|
| @@ -5743,22 +5776,22 @@ class HLoadKeyed FINAL
|
| return Representation::None();
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) OVERRIDE {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return RequiredInputRepresentation(index);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| bool UsesMustHandleHole() const;
|
| bool AllUsesCanTreatHoleAsNaN() const;
|
| bool RequiresHoleCheck() const;
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE;
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadKeyed)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| if (!other->IsLoadKeyed()) return false;
|
| HLoadKeyed* other_load = HLoadKeyed::cast(other);
|
|
|
| @@ -5818,7 +5851,7 @@ class HLoadKeyed FINAL
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !RequiresHoleCheck();
|
| }
|
|
|
| @@ -5854,7 +5887,7 @@ class HLoadKeyed FINAL
|
| };
|
|
|
|
|
| -class HLoadKeyedGeneric FINAL : public HTemplateInstruction<3> {
|
| +class HLoadKeyedGeneric V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HLoadKeyedGeneric(HValue* context, HValue* obj, HValue* key) {
|
| set_representation(Representation::Tagged());
|
| @@ -5868,28 +5901,30 @@ class HLoadKeyedGeneric FINAL : public HTemplateInstruction<3> {
|
| HValue* key() { return OperandAt(1); }
|
| HValue* context() { return OperandAt(2); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // tagged[tagged]
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HValue* Canonicalize() OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric)
|
| };
|
|
|
|
|
| -class HStoreNamedField FINAL : 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) OVERRIDE { return index == 1; }
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE {
|
| + return index == 1;
|
| + }
|
| + 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();
|
| @@ -5902,11 +5937,11 @@ class HStoreNamedField FINAL : public HTemplateInstruction<3> {
|
| return Representation::Tagged();
|
| }
|
| virtual void HandleSideEffectDominator(GVNFlag side_effect,
|
| - HValue* dominator) OVERRIDE {
|
| + HValue* dominator) V8_OVERRIDE {
|
| ASSERT(side_effect == kChangesNewSpacePromotion);
|
| new_space_dominator_ = dominator;
|
| }
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| void SkipWriteBarrier() { write_barrier_mode_ = SKIP_WRITE_BARRIER; }
|
| bool IsSkipWriteBarrier() const {
|
| @@ -5981,7 +6016,7 @@ class HStoreNamedField FINAL : public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HStoreNamedGeneric FINAL : public HTemplateInstruction<3> {
|
| +class HStoreNamedGeneric V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HStoreNamedGeneric(HValue* context,
|
| HValue* object,
|
| @@ -6002,9 +6037,9 @@ class HStoreNamedGeneric FINAL : public HTemplateInstruction<3> {
|
| Handle<String> name() { return name_; }
|
| StrictModeFlag strict_mode_flag() { return strict_mode_flag_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6016,13 +6051,13 @@ class HStoreNamedGeneric FINAL : public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HStoreKeyed FINAL
|
| +class HStoreKeyed V8_FINAL
|
| : public HTemplateInstruction<3>, public ArrayInstructionInterface {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P4(HStoreKeyed, HValue*, HValue*, HValue*,
|
| ElementsKind);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // kind_fast: tagged[int32] = tagged
|
| // kind_double: tagged[int32] = double
|
| // kind_smi : tagged[int32] = smi
|
| @@ -6052,7 +6087,7 @@ class HStoreKeyed FINAL
|
| return IsExternalArrayElementsKind(elements_kind());
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) OVERRIDE {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| if (index < 2) return RequiredInputRepresentation(index);
|
| if (IsUninitialized()) {
|
| return Representation::None();
|
| @@ -6093,7 +6128,7 @@ class HStoreKeyed FINAL
|
| }
|
|
|
| virtual void HandleSideEffectDominator(GVNFlag side_effect,
|
| - HValue* dominator) OVERRIDE {
|
| + HValue* dominator) V8_OVERRIDE {
|
| ASSERT(side_effect == kChangesNewSpacePromotion);
|
| new_space_dominator_ = dominator;
|
| }
|
| @@ -6111,7 +6146,7 @@ class HStoreKeyed FINAL
|
|
|
| bool NeedsCanonicalization();
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreKeyed)
|
|
|
| @@ -6157,7 +6192,7 @@ class HStoreKeyed FINAL
|
| };
|
|
|
|
|
| -class HStoreKeyedGeneric FINAL : public HTemplateInstruction<4> {
|
| +class HStoreKeyedGeneric V8_FINAL : public HTemplateInstruction<4> {
|
| public:
|
| HStoreKeyedGeneric(HValue* context,
|
| HValue* object,
|
| @@ -6178,12 +6213,12 @@ class HStoreKeyedGeneric FINAL : public HTemplateInstruction<4> {
|
| HValue* context() { return OperandAt(3); }
|
| StrictModeFlag strict_mode_flag() { return strict_mode_flag_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // tagged[tagged] = tagged
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric)
|
|
|
| @@ -6192,7 +6227,7 @@ class HStoreKeyedGeneric FINAL : public HTemplateInstruction<4> {
|
| };
|
|
|
|
|
| -class HTransitionElementsKind FINAL : public HTemplateInstruction<2> {
|
| +class HTransitionElementsKind V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| inline static HTransitionElementsKind* New(Zone* zone,
|
| HValue* context,
|
| @@ -6203,7 +6238,7 @@ class HTransitionElementsKind FINAL : public HTemplateInstruction<2> {
|
| original_map, transitioned_map);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6214,9 +6249,9 @@ class HTransitionElementsKind FINAL : public HTemplateInstruction<2> {
|
| ElementsKind from_kind() { return from_kind_; }
|
| ElementsKind to_kind() { return to_kind_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual void FinalizeUniqueValueId() OVERRIDE {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| original_map_unique_id_ = UniqueValueId(original_map_);
|
| transitioned_map_unique_id_ = UniqueValueId(transitioned_map_);
|
| }
|
| @@ -6224,7 +6259,7 @@ class HTransitionElementsKind FINAL : public HTemplateInstruction<2> {
|
| DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + 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_;
|
| @@ -6261,7 +6296,7 @@ class HTransitionElementsKind FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HStringAdd FINAL : public HBinaryOperation {
|
| +class HStringAdd V8_FINAL : public HBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -6271,14 +6306,14 @@ class HStringAdd FINAL : public HBinaryOperation {
|
|
|
| StringAddFlags flags() const { return flags_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StringAdd)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HStringAdd(HValue* context, HValue* left, HValue* right, StringAddFlags flags)
|
| @@ -6291,13 +6326,13 @@ class HStringAdd FINAL : public HBinaryOperation {
|
|
|
| // No side-effects except possible allocation.
|
| // NOTE: this instruction _does not_ call ToString() on its inputs.
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| const StringAddFlags flags_;
|
| };
|
|
|
|
|
| -class HStringCharCodeAt FINAL : public HTemplateInstruction<3> {
|
| +class HStringCharCodeAt V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| static HStringCharCodeAt* New(Zone* zone,
|
| HValue* context,
|
| @@ -6320,9 +6355,9 @@ class HStringCharCodeAt FINAL : public HTemplateInstruction<3> {
|
| DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone) OVERRIDE {
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE {
|
| return new(zone) Range(0, String::kMaxUtf16CodeUnit);
|
| }
|
|
|
| @@ -6338,17 +6373,17 @@ class HStringCharCodeAt FINAL : public HTemplateInstruction<3> {
|
| }
|
|
|
| // No side effects: runtime function assumes string + number inputs.
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HStringCharFromCode FINAL : 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) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return index == 0
|
| ? Representation::Tagged()
|
| : Representation::Integer32();
|
| @@ -6357,7 +6392,7 @@ class HStringCharFromCode FINAL : public HTemplateInstruction<2> {
|
| HValue* context() const { return OperandAt(0); }
|
| HValue* value() const { return OperandAt(1); }
|
|
|
| - virtual bool DataEquals(HValue* other) OVERRIDE { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode)
|
|
|
| @@ -6371,7 +6406,7 @@ class HStringCharFromCode FINAL : public HTemplateInstruction<2> {
|
| SetGVNFlag(kChangesNewSpacePromotion);
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !value()->ToNumberCanBeObserved();
|
| }
|
| };
|
| @@ -6398,7 +6433,7 @@ class HMaterializedLiteral : public HTemplateInstruction<V> {
|
| }
|
|
|
| private:
|
| - virtual bool IsDeletable() const FINAL OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; }
|
|
|
| int literal_index_;
|
| int depth_;
|
| @@ -6406,7 +6441,7 @@ class HMaterializedLiteral : public HTemplateInstruction<V> {
|
| };
|
|
|
|
|
| -class HRegExpLiteral FINAL : public HMaterializedLiteral<1> {
|
| +class HRegExpLiteral V8_FINAL : public HMaterializedLiteral<1> {
|
| public:
|
| HRegExpLiteral(HValue* context,
|
| Handle<FixedArray> literals,
|
| @@ -6427,7 +6462,7 @@ class HRegExpLiteral FINAL : public HMaterializedLiteral<1> {
|
| Handle<String> pattern() { return pattern_; }
|
| Handle<String> flags() { return flags_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6440,7 +6475,7 @@ class HRegExpLiteral FINAL : public HMaterializedLiteral<1> {
|
| };
|
|
|
|
|
| -class HFunctionLiteral FINAL : public HTemplateInstruction<1> {
|
| +class HFunctionLiteral V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| HFunctionLiteral(HValue* context,
|
| Handle<SharedFunctionInfo> shared,
|
| @@ -6458,7 +6493,7 @@ class HFunctionLiteral FINAL : public HTemplateInstruction<1> {
|
|
|
| HValue* context() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6471,7 +6506,7 @@ class HFunctionLiteral FINAL : public HTemplateInstruction<1> {
|
| LanguageMode language_mode() const { return language_mode_; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| Handle<SharedFunctionInfo> shared_info_;
|
| bool pretenure_ : 1;
|
| @@ -6481,7 +6516,7 @@ class HFunctionLiteral FINAL : public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HTypeof FINAL : public HTemplateInstruction<2> {
|
| +class HTypeof V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| explicit HTypeof(HValue* context, HValue* value) {
|
| SetOperandAt(0, context);
|
| @@ -6492,24 +6527,24 @@ class HTypeof FINAL : public HTemplateInstruction<2> {
|
| HValue* context() { return OperandAt(0); }
|
| HValue* value() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Typeof)
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HTrapAllocationMemento FINAL : public HTemplateInstruction<1> {
|
| +class HTrapAllocationMemento V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HTrapAllocationMemento, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6524,11 +6559,11 @@ class HTrapAllocationMemento FINAL : public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HToFastProperties FINAL : public HUnaryOperation {
|
| +class HToFastProperties V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HToFastProperties, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6550,28 +6585,28 @@ class HToFastProperties FINAL : public HUnaryOperation {
|
| #endif
|
| }
|
|
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HValueOf FINAL : public HUnaryOperation {
|
| +class HValueOf V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HValueOf(HValue* value) : HUnaryOperation(value) {
|
| set_representation(Representation::Tagged());
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ValueOf)
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HDateField FINAL : public HUnaryOperation {
|
| +class HDateField V8_FINAL : public HUnaryOperation {
|
| public:
|
| HDateField(HValue* date, Smi* index)
|
| : HUnaryOperation(date), index_(index) {
|
| @@ -6580,7 +6615,7 @@ class HDateField FINAL : public HUnaryOperation {
|
|
|
| Smi* index() const { return index_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6591,7 +6626,7 @@ class HDateField FINAL : public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HSeqStringSetChar FINAL : public HTemplateInstruction<3> {
|
| +class HSeqStringSetChar V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HSeqStringSetChar(String::Encoding encoding,
|
| HValue* string,
|
| @@ -6608,7 +6643,7 @@ class HSeqStringSetChar FINAL : public HTemplateInstruction<3> {
|
| HValue* index() { return OperandAt(1); }
|
| HValue* value() { return OperandAt(2); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return (index == 0) ? Representation::Tagged()
|
| : Representation::Integer32();
|
| }
|
| @@ -6620,17 +6655,17 @@ class HSeqStringSetChar FINAL : public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HCheckMapValue FINAL : public HTemplateInstruction<2> {
|
| +class HCheckMapValue V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HCheckMapValue, HValue*, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() OVERRIDE {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| @@ -6640,7 +6675,7 @@ class HCheckMapValue FINAL : public HTemplateInstruction<2> {
|
| DECLARE_CONCRETE_INSTRUCTION(CheckMapValue)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) OVERRIDE {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| return true;
|
| }
|
|
|
| @@ -6657,7 +6692,7 @@ class HCheckMapValue FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HForInPrepareMap FINAL : public HTemplateInstruction<2> {
|
| +class HForInPrepareMap V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HForInPrepareMap* New(Zone* zone,
|
| HValue* context,
|
| @@ -6665,16 +6700,16 @@ class HForInPrepareMap FINAL : public HTemplateInstruction<2> {
|
| return new(zone) HForInPrepareMap(context, object);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + 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) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() OVERRIDE {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| @@ -6691,11 +6726,11 @@ class HForInPrepareMap FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HForInCacheArray FINAL : public HTemplateInstruction<2> {
|
| +class HForInCacheArray V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P3(HForInCacheArray, HValue*, HValue*, int);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6711,9 +6746,9 @@ class HForInCacheArray FINAL : public HTemplateInstruction<2> {
|
| index_cache_ = index_cache;
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() OVERRIDE {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| @@ -6733,7 +6768,7 @@ class HForInCacheArray FINAL : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HLoadFieldByIndex FINAL : public HTemplateInstruction<2> {
|
| +class HLoadFieldByIndex V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HLoadFieldByIndex(HValue* object,
|
| HValue* index) {
|
| @@ -6742,23 +6777,23 @@ class HLoadFieldByIndex FINAL : public HTemplateInstruction<2> {
|
| set_representation(Representation::Tagged());
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) OVERRIDE {
|
| + 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) OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() OVERRIDE {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex);
|
|
|
| private:
|
| - virtual bool IsDeletable() const OVERRIDE { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
|
|
Chromium Code Reviews
Issue 23064017:
Use V8_FINAL and V8_OVERRIDE in various places, fixing bugs revealed by them. (Closed)
Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge