| Index: src/hydrogen-instructions.h
|
| diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h
|
| index 887168cc755d6779be50924c417fb3c79d9b776f..bef46df4ec53b5f6b78b0bccaf6781a64a05b1fc 100644
|
| --- a/src/hydrogen-instructions.h
|
| +++ b/src/hydrogen-instructions.h
|
| @@ -210,24 +210,27 @@ class LChunkBuilder;
|
| V(ExternalMemory)
|
|
|
|
|
| -#define DECLARE_ABSTRACT_INSTRUCTION(type) \
|
| - virtual bool Is##type() const { return true; } \
|
| - static H##type* cast(HValue* value) { \
|
| - ASSERT(value->Is##type()); \
|
| - return reinterpret_cast<H##type*>(value); \
|
| +#define DECLARE_ABSTRACT_INSTRUCTION(type) \
|
| + virtual bool Is##type() const V8_FINAL V8_OVERRIDE { return true; } \
|
| + static H##type* cast(HValue* value) { \
|
| + ASSERT(value->Is##type()); \
|
| + return reinterpret_cast<H##type*>(value); \
|
| }
|
|
|
|
|
| -#define DECLARE_CONCRETE_INSTRUCTION(type) \
|
| - virtual LInstruction* CompileToLithium(LChunkBuilder* builder); \
|
| - static H##type* cast(HValue* value) { \
|
| - ASSERT(value->Is##type()); \
|
| - return reinterpret_cast<H##type*>(value); \
|
| - } \
|
| - virtual Opcode opcode() const { return HValue::k##type; }
|
| +#define DECLARE_CONCRETE_INSTRUCTION(type) \
|
| + virtual LInstruction* CompileToLithium( \
|
| + LChunkBuilder* builder) V8_FINAL V8_OVERRIDE; \
|
| + static H##type* cast(HValue* value) { \
|
| + ASSERT(value->Is##type()); \
|
| + return reinterpret_cast<H##type*>(value); \
|
| + } \
|
| + virtual Opcode opcode() const V8_FINAL V8_OVERRIDE { \
|
| + return HValue::k##type; \
|
| + }
|
|
|
|
|
| -class Range: public ZoneObject {
|
| +class Range V8_FINAL : public ZoneObject {
|
| public:
|
| Range()
|
| : lower_(kMinInt),
|
| @@ -302,7 +305,7 @@ class Range: public ZoneObject {
|
| };
|
|
|
|
|
| -class UniqueValueId {
|
| +class UniqueValueId V8_FINAL {
|
| public:
|
| UniqueValueId() : raw_address_(NULL) { }
|
|
|
| @@ -344,7 +347,7 @@ class UniqueValueId {
|
| };
|
|
|
|
|
| -class HType {
|
| +class HType V8_FINAL {
|
| public:
|
| static HType None() { return HType(kNone); }
|
| static HType Tagged() { return HType(kTagged); }
|
| @@ -495,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 BASE_EMBEDDED {
|
| +class HUseIterator V8_FINAL BASE_EMBEDDED {
|
| public:
|
| bool Done() { return current_ == NULL; }
|
| void Advance();
|
| @@ -539,7 +542,7 @@ enum GVNFlag {
|
| };
|
|
|
|
|
| -class DecompositionResult BASE_EMBEDDED {
|
| +class DecompositionResult V8_FINAL BASE_EMBEDDED {
|
| public:
|
| DecompositionResult() : base_(NULL), offset_(0), scale_(0) {}
|
|
|
| @@ -587,7 +590,7 @@ class DecompositionResult BASE_EMBEDDED {
|
| typedef EnumSet<GVNFlag> GVNFlagSet;
|
|
|
|
|
| -class HValue: public ZoneObject {
|
| +class HValue : public ZoneObject {
|
| public:
|
| static const int kNoNumber = -1;
|
|
|
| @@ -1082,12 +1085,12 @@ class HValue: public ZoneObject {
|
| }
|
|
|
|
|
| -class HInstruction: public HValue {
|
| +class HInstruction : public HValue {
|
| public:
|
| HInstruction* next() const { return next_; }
|
| HInstruction* previous() const { return previous_; }
|
|
|
| - virtual void PrintTo(StringStream* stream);
|
| + virtual void PrintTo(StringStream* stream) V8_OVERRIDE;
|
| virtual void PrintDataTo(StringStream* stream);
|
|
|
| bool IsLinked() const { return block() != NULL; }
|
| @@ -1109,7 +1112,7 @@ class HInstruction: public HValue {
|
| virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0;
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify();
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| virtual bool IsCall() { return false; }
|
| @@ -1125,7 +1128,7 @@ class HInstruction: public HValue {
|
| SetGVNFlag(kDependsOnOsrEntries);
|
| }
|
|
|
| - virtual void DeleteFromGraph() { Unlink(); }
|
| + virtual void DeleteFromGraph() V8_OVERRIDE { Unlink(); }
|
|
|
| private:
|
| void InitializeAsFirst(HBasicBlock* block) {
|
| @@ -1146,26 +1149,30 @@ class HInstruction: public HValue {
|
| template<int V>
|
| class HTemplateInstruction : public HInstruction {
|
| public:
|
| - int OperandCount() { return V; }
|
| - HValue* OperandAt(int i) const { return inputs_[i]; }
|
| + virtual int OperandCount() V8_FINAL V8_OVERRIDE { return V; }
|
| + virtual HValue* OperandAt(int i) const V8_FINAL V8_OVERRIDE {
|
| + return inputs_[i];
|
| + }
|
|
|
| protected:
|
| HTemplateInstruction(HType type = HType::Tagged()) : HInstruction(type) {}
|
|
|
| - void InternalSetOperandAt(int i, HValue* value) { inputs_[i] = value; }
|
| + virtual void InternalSetOperandAt(int i, HValue* value) V8_FINAL V8_OVERRIDE {
|
| + inputs_[i] = value;
|
| + }
|
|
|
| private:
|
| EmbeddedContainer<HValue*, V> inputs_;
|
| };
|
|
|
|
|
| -class HControlInstruction: public HInstruction {
|
| +class HControlInstruction : public HInstruction {
|
| public:
|
| virtual HBasicBlock* SuccessorAt(int i) = 0;
|
| virtual int SuccessorCount() = 0;
|
| virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0;
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HBasicBlock* FirstSuccessor() {
|
| return SuccessorCount() > 0 ? SuccessorAt(0) : NULL;
|
| @@ -1178,7 +1185,7 @@ class HControlInstruction: public HInstruction {
|
| };
|
|
|
|
|
| -class HSuccessorIterator BASE_EMBEDDED {
|
| +class HSuccessorIterator V8_FINAL BASE_EMBEDDED {
|
| public:
|
| explicit HSuccessorIterator(HControlInstruction* instr)
|
| : instr_(instr), current_(0) { }
|
| @@ -1194,18 +1201,22 @@ class HSuccessorIterator BASE_EMBEDDED {
|
|
|
|
|
| template<int S, int V>
|
| -class HTemplateControlInstruction: public HControlInstruction {
|
| +class HTemplateControlInstruction : public HControlInstruction {
|
| public:
|
| - int SuccessorCount() { return S; }
|
| - HBasicBlock* SuccessorAt(int i) { return successors_[i]; }
|
| - void SetSuccessorAt(int i, HBasicBlock* block) { successors_[i] = block; }
|
| + int SuccessorCount() V8_OVERRIDE { return S; }
|
| + HBasicBlock* SuccessorAt(int i) V8_OVERRIDE { return successors_[i]; }
|
| + void SetSuccessorAt(int i, HBasicBlock* block) V8_OVERRIDE {
|
| + successors_[i] = block;
|
| + }
|
|
|
| - int OperandCount() { return V; }
|
| - HValue* OperandAt(int i) const { return inputs_[i]; }
|
| + int OperandCount() V8_OVERRIDE { return V; }
|
| + HValue* OperandAt(int i) const V8_OVERRIDE { return inputs_[i]; }
|
|
|
|
|
| protected:
|
| - void InternalSetOperandAt(int i, HValue* value) { inputs_[i] = value; }
|
| + void InternalSetOperandAt(int i, HValue* value) V8_OVERRIDE {
|
| + inputs_[i] = value;
|
| + }
|
|
|
| private:
|
| EmbeddedContainer<HBasicBlock*, S> successors_;
|
| @@ -1213,9 +1224,9 @@ class HTemplateControlInstruction: public HControlInstruction {
|
| };
|
|
|
|
|
| -class HBlockEntry: public HTemplateInstruction<0> {
|
| +class HBlockEntry V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1223,7 +1234,7 @@ class HBlockEntry: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HDummyUse: public HTemplateInstruction<1> {
|
| +class HDummyUse V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| explicit HDummyUse(HValue* value)
|
| : HTemplateInstruction<1>(HType::Smi()) {
|
| @@ -1235,23 +1246,23 @@ class HDummyUse: public HTemplateInstruction<1> {
|
|
|
| HValue* value() { return OperandAt(0); }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(DummyUse);
|
| };
|
|
|
|
|
| -class HDeoptimize: public HTemplateInstruction<0> {
|
| +class HDeoptimize V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HDeoptimize, const char*,
|
| Deoptimizer::BailoutType);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1270,9 +1281,9 @@ class HDeoptimize: public HTemplateInstruction<0> {
|
|
|
|
|
| // Inserts an int3/stop break instruction for debugging purposes.
|
| -class HDebugBreak: public HTemplateInstruction<0> {
|
| +class HDebugBreak V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1280,23 +1291,23 @@ class HDebugBreak: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HGoto: public HTemplateControlInstruction<1, 0> {
|
| +class HGoto V8_FINAL : public HTemplateControlInstruction<1, 0> {
|
| public:
|
| explicit HGoto(HBasicBlock* target) {
|
| SetSuccessorAt(0, target);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Goto)
|
| };
|
|
|
|
|
| -class HUnaryControlInstruction: public HTemplateControlInstruction<2, 1> {
|
| +class HUnaryControlInstruction : public HTemplateControlInstruction<2, 1> {
|
| public:
|
| HUnaryControlInstruction(HValue* value,
|
| HBasicBlock* true_target,
|
| @@ -1306,13 +1317,13 @@ class HUnaryControlInstruction: public HTemplateControlInstruction<2, 1> {
|
| SetSuccessorAt(1, false_target);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| };
|
|
|
|
|
| -class HBranch: public HUnaryControlInstruction {
|
| +class HBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HBranch(HValue* value,
|
| ToBooleanStub::Types expected_input_types = ToBooleanStub::Types(),
|
| @@ -1323,10 +1334,10 @@ class HBranch: public HUnaryControlInstruction {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
| - virtual Representation observed_input_representation(int index);
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE;
|
|
|
| ToBooleanStub::Types expected_input_types() const {
|
| return expected_input_types_;
|
| @@ -1339,7 +1350,7 @@ class HBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HCompareMap: public HUnaryControlInstruction {
|
| +class HCompareMap V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HCompareMap(HValue* value,
|
| Handle<Map> map,
|
| @@ -1350,11 +1361,11 @@ class HCompareMap: public HUnaryControlInstruction {
|
| ASSERT(!map.is_null());
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<Map> map() const { return map_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1365,20 +1376,20 @@ class HCompareMap: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HContext: public HTemplateInstruction<0> {
|
| +class HContext V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| static HContext* New(Zone* zone) {
|
| return new(zone) HContext();
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Context)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HContext() {
|
| @@ -1386,11 +1397,11 @@ class HContext: public HTemplateInstruction<0> {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HReturn: public HTemplateControlInstruction<0, 3> {
|
| +class HReturn V8_FINAL : public HTemplateControlInstruction<0, 3> {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -1405,11 +1416,11 @@ class HReturn: public HTemplateControlInstruction<0, 3> {
|
| return new(zone) HReturn(value, context, 0);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| HValue* context() { return OperandAt(1); }
|
| @@ -1426,9 +1437,9 @@ class HReturn: public HTemplateControlInstruction<0, 3> {
|
| };
|
|
|
|
|
| -class HAbnormalExit: public HTemplateControlInstruction<0, 0> {
|
| +class HAbnormalExit V8_FINAL : public HTemplateControlInstruction<0, 0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1436,7 +1447,7 @@ class HAbnormalExit: public HTemplateControlInstruction<0, 0> {
|
| };
|
|
|
|
|
| -class HUnaryOperation: public HTemplateInstruction<1> {
|
| +class HUnaryOperation : public HTemplateInstruction<1> {
|
| public:
|
| HUnaryOperation(HValue* value, HType type = HType::Tagged())
|
| : HTemplateInstruction<1>(type) {
|
| @@ -1448,11 +1459,11 @@ class HUnaryOperation: public HTemplateInstruction<1> {
|
| }
|
|
|
| HValue* value() const { return OperandAt(0); }
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
| };
|
|
|
|
|
| -class HThrow: public HTemplateInstruction<2> {
|
| +class HThrow V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HThrow* New(Zone* zone,
|
| HValue* context,
|
| @@ -1460,7 +1471,7 @@ class HThrow: public HTemplateInstruction<2> {
|
| return new(zone) HThrow(context, value);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1478,11 +1489,11 @@ class HThrow: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HUseConst: public HUnaryOperation {
|
| +class HUseConst V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HUseConst, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1493,19 +1504,20 @@ class HUseConst: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HForceRepresentation: public HTemplateInstruction<1> {
|
| +class HForceRepresentation V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HForceRepresentation, HValue*, Representation);
|
|
|
| HValue* value() { return OperandAt(0); }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation(); // Same as the output representation.
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ForceRepresentation)
|
|
|
| @@ -1517,7 +1529,7 @@ class HForceRepresentation: public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HChange: public HUnaryOperation {
|
| +class HChange V8_FINAL : public HUnaryOperation {
|
| public:
|
| HChange(HValue* value,
|
| Representation to,
|
| @@ -1543,47 +1555,48 @@ class HChange: public HUnaryOperation {
|
| return CheckUsesForFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| - virtual HType CalculateInferredType();
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
| + virtual HType CalculateInferredType() V8_OVERRIDE;
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| Representation from() const { return value()->representation(); }
|
| Representation to() const { return representation(); }
|
| bool deoptimize_on_minus_zero() const {
|
| return CheckFlag(kBailoutOnMinusZero);
|
| }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return from();
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Change)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !from().IsTagged() || value()->type().IsSmi();
|
| }
|
| };
|
|
|
|
|
| -class HClampToUint8: public HUnaryOperation {
|
| +class HClampToUint8 V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HClampToUint8, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ClampToUint8)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HClampToUint8(HValue* value)
|
| @@ -1593,7 +1606,7 @@ class HClampToUint8: public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| @@ -1603,7 +1616,7 @@ enum RemovableSimulate {
|
| };
|
|
|
|
|
| -class HSimulate: public HInstruction {
|
| +class HSimulate V8_FINAL : public HInstruction {
|
| public:
|
| HSimulate(BailoutId ast_id,
|
| int pop_count,
|
| @@ -1615,9 +1628,9 @@ class HSimulate: public HInstruction {
|
| assigned_indexes_(2, zone),
|
| zone_(zone),
|
| removable_(removable) {}
|
| - virtual ~HSimulate() {}
|
| + ~HSimulate() {}
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| bool HasAstId() const { return !ast_id_.IsNone(); }
|
| BailoutId ast_id() const { return ast_id_; }
|
| @@ -1647,11 +1660,13 @@ class HSimulate: public HInstruction {
|
| }
|
| return -1;
|
| }
|
| - virtual int OperandCount() { return values_.length(); }
|
| - virtual HValue* OperandAt(int index) const { return values_[index]; }
|
| + virtual int OperandCount() V8_OVERRIDE { return values_.length(); }
|
| + virtual HValue* OperandAt(int index) const V8_OVERRIDE {
|
| + return values_[index];
|
| + }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1661,13 +1676,13 @@ class HSimulate: public HInstruction {
|
| DECLARE_CONCRETE_INSTRUCTION(Simulate)
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify();
|
| + virtual void Verify() V8_OVERRIDE;
|
| void set_closure(Handle<JSFunction> closure) { closure_ = closure; }
|
| Handle<JSFunction> closure() const { return closure_; }
|
| #endif
|
|
|
| protected:
|
| - virtual void InternalSetOperandAt(int index, HValue* value) {
|
| + virtual void InternalSetOperandAt(int index, HValue* value) V8_OVERRIDE {
|
| values_[index] = value;
|
| }
|
|
|
| @@ -1700,7 +1715,7 @@ class HSimulate: public HInstruction {
|
| };
|
|
|
|
|
| -class HEnvironmentMarker: public HTemplateInstruction<1> {
|
| +class HEnvironmentMarker V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| enum Kind { BIND, LOOKUP };
|
|
|
| @@ -1714,11 +1729,11 @@ class HEnvironmentMarker: public HTemplateInstruction<1> {
|
| next_simulate_ = simulate;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| #ifdef DEBUG
|
| void set_closure(Handle<JSFunction> closure) {
|
| @@ -1742,7 +1757,7 @@ class HEnvironmentMarker: public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HStackCheck: public HTemplateInstruction<1> {
|
| +class HStackCheck V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| enum Type {
|
| kFunctionEntry,
|
| @@ -1753,7 +1768,7 @@ class HStackCheck: public HTemplateInstruction<1> {
|
|
|
| HValue* context() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1792,7 +1807,7 @@ enum InliningKind {
|
| class HArgumentsObject;
|
|
|
|
|
| -class HEnterInlined: public HTemplateInstruction<0> {
|
| +class HEnterInlined V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| static HEnterInlined* New(Zone* zone,
|
| HValue* context,
|
| @@ -1811,7 +1826,7 @@ class HEnterInlined: public HTemplateInstruction<0> {
|
| void RegisterReturnTarget(HBasicBlock* return_target, Zone* zone);
|
| ZoneList<HBasicBlock*>* return_targets() { return &return_targets_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<JSFunction> closure() const { return closure_; }
|
| int arguments_count() const { return arguments_count_; }
|
| @@ -1821,7 +1836,7 @@ class HEnterInlined: public HTemplateInstruction<0> {
|
| InliningKind inlining_kind() const { return inlining_kind_; }
|
| bool undefined_receiver() const { return undefined_receiver_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1862,11 +1877,11 @@ class HEnterInlined: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HLeaveInlined: public HTemplateInstruction<0> {
|
| +class HLeaveInlined V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| HLeaveInlined() { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -1874,11 +1889,11 @@ class HLeaveInlined: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HPushArgument: public HUnaryOperation {
|
| +class HPushArgument V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HPushArgument, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1893,39 +1908,39 @@ class HPushArgument: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HThisFunction: public HTemplateInstruction<0> {
|
| +class HThisFunction V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| HThisFunction() {
|
| set_representation(Representation::Tagged());
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ThisFunction)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HOuterContext: public HUnaryOperation {
|
| +class HOuterContext V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HOuterContext, HValue*);
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(OuterContext);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HOuterContext(HValue* inner) : HUnaryOperation(inner) {
|
| @@ -1933,11 +1948,11 @@ class HOuterContext: public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HDeclareGlobals: public HUnaryOperation {
|
| +class HDeclareGlobals V8_FINAL : public HUnaryOperation {
|
| public:
|
| HDeclareGlobals(HValue* context,
|
| Handle<FixedArray> pairs,
|
| @@ -1962,7 +1977,7 @@ class HDeclareGlobals: public HUnaryOperation {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -1972,7 +1987,7 @@ class HDeclareGlobals: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HGlobalObject: public HUnaryOperation {
|
| +class HGlobalObject V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HGlobalObject(HValue* context) : HUnaryOperation(context) {
|
| set_representation(Representation::Tagged());
|
| @@ -1985,30 +2000,30 @@ class HGlobalObject: public HUnaryOperation {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(GlobalObject)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HGlobalReceiver: public HUnaryOperation {
|
| +class HGlobalReceiver V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HGlobalReceiver, HValue*);
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(GlobalReceiver)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HGlobalReceiver(HValue* global_object)
|
| @@ -2017,12 +2032,12 @@ class HGlobalReceiver: public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| template <int V>
|
| -class HCall: public HTemplateInstruction<V> {
|
| +class HCall : public HTemplateInstruction<V> {
|
| public:
|
| // The argument count includes the receiver.
|
| explicit HCall<V>(int argument_count) : argument_count_(argument_count) {
|
| @@ -2030,35 +2045,38 @@ class HCall: public HTemplateInstruction<V> {
|
| this->SetAllSideEffects();
|
| }
|
|
|
| - virtual HType CalculateInferredType() { return HType::Tagged(); }
|
| + virtual HType CalculateInferredType() V8_FINAL V8_OVERRIDE {
|
| + return HType::Tagged();
|
| + }
|
|
|
| virtual int argument_count() const { return argument_count_; }
|
|
|
| - virtual bool IsCall() { return true; }
|
| + virtual bool IsCall() V8_FINAL V8_OVERRIDE { return true; }
|
|
|
| private:
|
| int argument_count_;
|
| };
|
|
|
|
|
| -class HUnaryCall: public HCall<1> {
|
| +class HUnaryCall : public HCall<1> {
|
| public:
|
| HUnaryCall(HValue* value, int argument_count)
|
| : HCall<1>(argument_count) {
|
| SetOperandAt(0, value);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(
|
| + int index) V8_FINAL V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| };
|
|
|
|
|
| -class HBinaryCall: public HCall<2> {
|
| +class HBinaryCall : public HCall<2> {
|
| public:
|
| HBinaryCall(HValue* first, HValue* second, int argument_count)
|
| : HCall<2>(argument_count) {
|
| @@ -2066,9 +2084,10 @@ class HBinaryCall: public HCall<2> {
|
| SetOperandAt(1, second);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(
|
| + int index) V8_FINAL V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -2077,7 +2096,7 @@ class HBinaryCall: public HCall<2> {
|
| };
|
|
|
|
|
| -class HInvokeFunction: public HBinaryCall {
|
| +class HInvokeFunction V8_FINAL : public HBinaryCall {
|
| public:
|
| HInvokeFunction(HValue* context, HValue* function, int argument_count)
|
| : HBinaryCall(context, function, argument_count) {
|
| @@ -2109,10 +2128,6 @@ class HInvokeFunction: public HBinaryCall {
|
| known_function, argument_count);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return Representation::Tagged();
|
| - }
|
| -
|
| HValue* context() { return first(); }
|
| HValue* function() { return second(); }
|
| Handle<JSFunction> known_function() { return known_function_; }
|
| @@ -2126,7 +2141,7 @@ class HInvokeFunction: public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallConstantFunction: public HCall<0> {
|
| +class HCallConstantFunction V8_FINAL : public HCall<0> {
|
| public:
|
| HCallConstantFunction(Handle<JSFunction> function, int argument_count)
|
| : HCall<0>(argument_count),
|
| @@ -2141,9 +2156,9 @@ class HCallConstantFunction: public HCall<0> {
|
| Isolate::Current()->builtins()->builtin(Builtins::kFunctionApply);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -2155,16 +2170,12 @@ class HCallConstantFunction: public HCall<0> {
|
| };
|
|
|
|
|
| -class HCallKeyed: public HBinaryCall {
|
| +class HCallKeyed V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallKeyed(HValue* context, HValue* key, int argument_count)
|
| : HBinaryCall(context, key, argument_count) {
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return Representation::Tagged();
|
| - }
|
| -
|
| HValue* context() { return first(); }
|
| HValue* key() { return second(); }
|
|
|
| @@ -2172,29 +2183,25 @@ class HCallKeyed: public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallNamed: public HUnaryCall {
|
| +class HCallNamed V8_FINAL : public HUnaryCall {
|
| public:
|
| HCallNamed(HValue* context, Handle<String> name, int argument_count)
|
| : HUnaryCall(context, argument_count), name_(name) {
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* context() { return value(); }
|
| Handle<String> name() const { return name_; }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CallNamed)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return Representation::Tagged();
|
| - }
|
| -
|
| private:
|
| Handle<String> name_;
|
| };
|
|
|
|
|
| -class HCallFunction: public HBinaryCall {
|
| +class HCallFunction V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallFunction(HValue* context, HValue* function, int argument_count)
|
| : HBinaryCall(context, function, argument_count) {
|
| @@ -2210,15 +2217,11 @@ class HCallFunction: public HBinaryCall {
|
| HValue* context() { return first(); }
|
| HValue* function() { return second(); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return Representation::Tagged();
|
| - }
|
| -
|
| DECLARE_CONCRETE_INSTRUCTION(CallFunction)
|
| };
|
|
|
|
|
| -class HCallGlobal: public HUnaryCall {
|
| +class HCallGlobal V8_FINAL : public HUnaryCall {
|
| public:
|
| HCallGlobal(HValue* context, Handle<String> name, int argument_count)
|
| : HUnaryCall(context, argument_count), name_(name) {
|
| @@ -2231,15 +2234,11 @@ class HCallGlobal: public HUnaryCall {
|
| return new(zone) HCallGlobal(context, name, argument_count);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* context() { return value(); }
|
| Handle<String> name() const { return name_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return Representation::Tagged();
|
| - }
|
| -
|
| DECLARE_CONCRETE_INSTRUCTION(CallGlobal)
|
|
|
| private:
|
| @@ -2247,19 +2246,19 @@ class HCallGlobal: public HUnaryCall {
|
| };
|
|
|
|
|
| -class HCallKnownGlobal: public HCall<0> {
|
| +class HCallKnownGlobal V8_FINAL : public HCall<0> {
|
| public:
|
| HCallKnownGlobal(Handle<JSFunction> target, int argument_count)
|
| : HCall<0>(argument_count),
|
| target_(target),
|
| formal_parameter_count_(target->shared()->formal_parameter_count()) { }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<JSFunction> target() const { return target_; }
|
| int formal_parameter_count() const { return formal_parameter_count_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -2271,15 +2270,10 @@ class HCallKnownGlobal: public HCall<0> {
|
| };
|
|
|
|
|
| -class HCallNew: public HBinaryCall {
|
| +class HCallNew V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallNew(HValue* context, HValue* constructor, int argument_count)
|
| - : HBinaryCall(context, constructor, argument_count) {
|
| - }
|
| -
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return Representation::Tagged();
|
| - }
|
| + : HBinaryCall(context, constructor, argument_count) {}
|
|
|
| HValue* context() { return first(); }
|
| HValue* constructor() { return second(); }
|
| @@ -2288,15 +2282,18 @@ class HCallNew: public HBinaryCall {
|
| };
|
|
|
|
|
| -class HCallNewArray: public HCallNew {
|
| +class HCallNewArray V8_FINAL : public HBinaryCall {
|
| public:
|
| HCallNewArray(HValue* context, HValue* constructor, int argument_count,
|
| Handle<Cell> type_cell, ElementsKind elements_kind)
|
| - : HCallNew(context, constructor, argument_count),
|
| + : HBinaryCall(context, constructor, argument_count),
|
| elements_kind_(elements_kind),
|
| type_cell_(type_cell) {}
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + HValue* context() { return first(); }
|
| + HValue* constructor() { return second(); }
|
| +
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<Cell> property_cell() const {
|
| return type_cell_;
|
| @@ -2312,7 +2309,7 @@ class HCallNewArray: public HCallNew {
|
| };
|
|
|
|
|
| -class HCallRuntime: public HCall<1> {
|
| +class HCallRuntime V8_FINAL : public HCall<1> {
|
| public:
|
| static HCallRuntime* New(Zone* zone,
|
| HValue* context,
|
| @@ -2322,13 +2319,13 @@ class HCallRuntime: public HCall<1> {
|
| return new(zone) HCallRuntime(context, name, c_function, argument_count);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* context() { return OperandAt(0); }
|
| const Runtime::Function* function() const { return c_function_; }
|
| Handle<String> name() const { return name_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -2348,18 +2345,18 @@ class HCallRuntime: public HCall<1> {
|
| };
|
|
|
|
|
| -class HMapEnumLength: public HUnaryOperation {
|
| +class HMapEnumLength V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HMapEnumLength, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(MapEnumLength)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HMapEnumLength(HValue* value)
|
| @@ -2369,11 +2366,11 @@ class HMapEnumLength: public HUnaryOperation {
|
| SetGVNFlag(kDependsOnMaps);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HElementsKind: public HUnaryOperation {
|
| +class HElementsKind V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HElementsKind(HValue* value) : HUnaryOperation(value) {
|
| set_representation(Representation::Integer32());
|
| @@ -2381,21 +2378,21 @@ class HElementsKind: public HUnaryOperation {
|
| SetGVNFlag(kDependsOnElementsKind);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ElementsKind)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HUnaryMathOperation: public HTemplateInstruction<2> {
|
| +class HUnaryMathOperation V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -2405,11 +2402,12 @@ class HUnaryMathOperation: public HTemplateInstruction<2> {
|
| HValue* context() { return OperandAt(0); }
|
| HValue* value() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0) {
|
| return Representation::Tagged();
|
| } else {
|
| @@ -2433,10 +2431,10 @@ class HUnaryMathOperation: public HTemplateInstruction<2> {
|
| }
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize();
|
| - virtual Representation RepresentationFromInputs();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE;
|
|
|
| BuiltinFunctionId op() const { return op_; }
|
| const char* OpName() const;
|
| @@ -2444,7 +2442,7 @@ class HUnaryMathOperation: public HTemplateInstruction<2> {
|
| DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HUnaryMathOperation* b = HUnaryMathOperation::cast(other);
|
| return op_ == b->op();
|
| }
|
| @@ -2486,28 +2484,28 @@ class HUnaryMathOperation: public HTemplateInstruction<2> {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| BuiltinFunctionId op_;
|
| };
|
|
|
|
|
| -class HLoadExternalArrayPointer: public HUnaryOperation {
|
| +class HLoadExternalArrayPointer V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HLoadExternalArrayPointer, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HType CalculateInferredType() {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadExternalArrayPointer)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HLoadExternalArrayPointer(HValue* value)
|
| @@ -2520,11 +2518,11 @@ class HLoadExternalArrayPointer: public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HCheckMaps: public HTemplateInstruction<2> {
|
| +class HCheckMaps V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HCheckMaps* New(Zone* zone, HValue* context, HValue* value,
|
| Handle<Map> map, CompilationInfo* info,
|
| @@ -2542,13 +2540,13 @@ class HCheckMaps: public HTemplateInstruction<2> {
|
|
|
| bool CanOmitMapChecks() { return omit_; }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
| virtual void HandleSideEffectDominator(GVNFlag side_effect,
|
| - HValue* dominator);
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + HValue* dominator) V8_OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| HValue* value() { return OperandAt(0); }
|
| SmallMapList* map_set() { return &map_set_; }
|
| @@ -2557,12 +2555,12 @@ class HCheckMaps: public HTemplateInstruction<2> {
|
| return has_migration_target_;
|
| }
|
|
|
| - virtual void FinalizeUniqueValueId();
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CheckMaps)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| ASSERT_EQ(map_set_.length(), map_unique_ids_.length());
|
| HCheckMaps* b = HCheckMaps::cast(other);
|
| // Relies on the fact that map_set has been sorted before.
|
| @@ -2617,22 +2615,22 @@ class HCheckMaps: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HCheckFunction: public HUnaryOperation {
|
| +class HCheckFunction V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HCheckFunction, HValue*, Handle<JSFunction>);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify();
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| - virtual void FinalizeUniqueValueId() {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| target_unique_id_ = UniqueValueId(target_);
|
| }
|
|
|
| @@ -2642,7 +2640,7 @@ class HCheckFunction: public HUnaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(CheckFunction)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HCheckFunction* b = HCheckFunction::cast(other);
|
| return target_unique_id_ == b->target_unique_id_;
|
| }
|
| @@ -2662,7 +2660,7 @@ class HCheckFunction: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HCheckInstanceType: public HUnaryOperation {
|
| +class HCheckInstanceType V8_FINAL : public HUnaryOperation {
|
| public:
|
| static HCheckInstanceType* NewIsSpecObject(HValue* value, Zone* zone) {
|
| return new(zone) HCheckInstanceType(value, IS_SPEC_OBJECT);
|
| @@ -2678,13 +2676,13 @@ class HCheckInstanceType: public HUnaryOperation {
|
| return new(zone) HCheckInstanceType(value, IS_INTERNALIZED_STRING);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| bool is_interval_check() const { return check_ <= LAST_INTERVAL_CHECK; }
|
| void GetCheckInterval(InstanceType* first, InstanceType* last);
|
| @@ -2696,7 +2694,7 @@ class HCheckInstanceType: public HUnaryOperation {
|
| // TODO(ager): It could be nice to allow the ommision of instance
|
| // type checks if we have already performed an instance type check
|
| // with a larger range.
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HCheckInstanceType* b = HCheckInstanceType::cast(other);
|
| return check_ == b->check_;
|
| }
|
| @@ -2722,15 +2720,15 @@ class HCheckInstanceType: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HCheckSmi: public HUnaryOperation {
|
| +class HCheckSmi V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HCheckSmi, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HValue* Canonicalize() {
|
| + virtual HValue* Canonicalize() V8_OVERRIDE {
|
| HType value_type = value()->type();
|
| if (value_type.IsSmi()) {
|
| return NULL;
|
| @@ -2741,7 +2739,7 @@ class HCheckSmi: public HUnaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(CheckSmi)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) {
|
| @@ -2751,14 +2749,14 @@ class HCheckSmi: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HIsNumberAndBranch: public HUnaryControlInstruction {
|
| +class HIsNumberAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsNumberAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) {
|
| SetFlag(kFlexibleRepresentation);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -2766,27 +2764,27 @@ class HIsNumberAndBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HCheckHeapObject: public HUnaryOperation {
|
| +class HCheckHeapObject V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HCheckHeapObject, HValue*);
|
|
|
| - virtual bool HasEscapingOperandAt(int index) { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify();
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| - virtual HValue* Canonicalize() {
|
| + virtual HValue* Canonicalize() V8_OVERRIDE {
|
| return value()->type().IsHeapObject() ? NULL : this;
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HCheckHeapObject(HValue* value)
|
| @@ -2818,7 +2816,7 @@ class HConstant;
|
| class HBitwise;
|
|
|
|
|
| -class InductionVariableData : public ZoneObject {
|
| +class InductionVariableData V8_FINAL : public ZoneObject {
|
| public:
|
| class InductionVariableCheck : public ZoneObject {
|
| public:
|
| @@ -3018,7 +3016,7 @@ class InductionVariableData : public ZoneObject {
|
| };
|
|
|
|
|
| -class HPhi: public HValue {
|
| +class HPhi V8_FINAL : public HValue {
|
| public:
|
| HPhi(int merged_index, Zone* zone)
|
| : inputs_(2, zone),
|
| @@ -3034,19 +3032,22 @@ class HPhi: public HValue {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual Representation RepresentationFromInputs();
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE;
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer);
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
| - virtual Representation KnownOptimalRepresentation() {
|
| + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE {
|
| return representation();
|
| }
|
| - virtual HType CalculateInferredType();
|
| - virtual int OperandCount() { return inputs_.length(); }
|
| - virtual HValue* OperandAt(int index) const { return inputs_[index]; }
|
| + virtual HType CalculateInferredType() V8_OVERRIDE;
|
| + virtual int OperandCount() V8_OVERRIDE { return inputs_.length(); }
|
| + virtual HValue* OperandAt(int index) const V8_OVERRIDE {
|
| + return inputs_[index];
|
| + }
|
| HValue* GetRedundantReplacement();
|
| void AddInput(HValue* value);
|
| bool HasRealUses();
|
| @@ -3071,10 +3072,10 @@ class HPhi: public HValue {
|
| induction_variable_data_ = InductionVariableData::ExaminePhi(this);
|
| }
|
|
|
| - virtual void PrintTo(StringStream* stream);
|
| + virtual void PrintTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify();
|
| + virtual void Verify() V8_OVERRIDE;
|
| #endif
|
|
|
| void InitRealUses(int id);
|
| @@ -3111,7 +3112,7 @@ class HPhi: public HValue {
|
| ASSERT(value->IsPhi());
|
| return reinterpret_cast<HPhi*>(value);
|
| }
|
| - virtual Opcode opcode() const { return HValue::kPhi; }
|
| + virtual Opcode opcode() const V8_OVERRIDE { return HValue::kPhi; }
|
|
|
| void SimplifyConstantInputs();
|
|
|
| @@ -3119,8 +3120,8 @@ class HPhi: public HValue {
|
| static const int kInvalidMergedIndex = -1;
|
|
|
| protected:
|
| - virtual void DeleteFromGraph();
|
| - virtual void InternalSetOperandAt(int index, HValue* value) {
|
| + virtual void DeleteFromGraph() V8_OVERRIDE;
|
| + virtual void InternalSetOperandAt(int index, HValue* value) V8_OVERRIDE {
|
| inputs_[index] = value;
|
| }
|
|
|
| @@ -3134,25 +3135,31 @@ class HPhi: public HValue {
|
| InductionVariableData* induction_variable_data_;
|
|
|
| // TODO(titzer): we can't eliminate the receiver for generating backtraces
|
| - virtual bool IsDeletable() const { return !IsReceiver(); }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return !IsReceiver(); }
|
| };
|
|
|
|
|
| // Common base class for HArgumentsObject and HCapturedObject.
|
| -class HDematerializedObject: public HTemplateInstruction<0> {
|
| +class HDematerializedObject : public HInstruction {
|
| public:
|
| HDematerializedObject(int count, Zone* zone) : values_(count, zone) {}
|
|
|
| - virtual int OperandCount() { return values_.length(); }
|
| - virtual HValue* OperandAt(int index) const { return values_[index]; }
|
| + virtual int OperandCount() V8_FINAL V8_OVERRIDE { return values_.length(); }
|
| + virtual HValue* OperandAt(int index) const V8_FINAL V8_OVERRIDE {
|
| + return values_[index];
|
| + }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual bool HasEscapingOperandAt(int index) V8_FINAL V8_OVERRIDE {
|
| + return false;
|
| + }
|
| + virtual Representation RequiredInputRepresentation(
|
| + int index) V8_FINAL V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| protected:
|
| - virtual void InternalSetOperandAt(int index, HValue* value) {
|
| + virtual void InternalSetOperandAt(int index,
|
| + HValue* value) V8_FINAL V8_OVERRIDE {
|
| values_[index] = value;
|
| }
|
|
|
| @@ -3160,11 +3167,11 @@ class HDematerializedObject: public HTemplateInstruction<0> {
|
| ZoneList<HValue*> values_;
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HArgumentsObject: public HDematerializedObject {
|
| +class HArgumentsObject V8_FINAL : public HDematerializedObject {
|
| public:
|
| static HArgumentsObject* New(Zone* zone, HValue* context, int count) {
|
| return new(zone) HArgumentsObject(count, zone);
|
| @@ -3191,7 +3198,7 @@ class HArgumentsObject: public HDematerializedObject {
|
| };
|
|
|
|
|
| -class HCapturedObject: public HDematerializedObject {
|
| +class HCapturedObject V8_FINAL : public HDematerializedObject {
|
| public:
|
| HCapturedObject(int length, Zone* zone)
|
| : HDematerializedObject(length, zone) {
|
| @@ -3209,7 +3216,7 @@ class HCapturedObject: public HDematerializedObject {
|
| };
|
|
|
|
|
| -class HConstant: public HTemplateInstruction<0> {
|
| +class HConstant V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HConstant, int32_t);
|
| DECLARE_INSTRUCTION_FACTORY_P2(HConstant, int32_t, Representation);
|
| @@ -3276,11 +3283,11 @@ class HConstant: public HTemplateInstruction<0> {
|
| return is_cell_;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| - virtual Representation KnownOptimalRepresentation() {
|
| + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE {
|
| if (HasSmiValue() && kSmiValueSize == 31) return Representation::Smi();
|
| if (HasInteger32Value()) return Representation::Integer32();
|
| if (HasNumberValue()) return Representation::Double();
|
| @@ -3288,8 +3295,8 @@ class HConstant: public HTemplateInstruction<0> {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual bool EmitAtUses();
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + 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);
|
| @@ -3346,7 +3353,7 @@ class HConstant: public HTemplateInstruction<0> {
|
| bool HasBooleanValue() const { return type_.IsBoolean(); }
|
| bool BooleanValue() const { return boolean_value_; }
|
|
|
| - virtual intptr_t Hashcode() {
|
| + virtual intptr_t Hashcode() V8_OVERRIDE {
|
| if (has_int32_value_) {
|
| return static_cast<intptr_t>(int32_value_);
|
| } else if (has_double_value_) {
|
| @@ -3359,7 +3366,7 @@ class HConstant: public HTemplateInstruction<0> {
|
| }
|
| }
|
|
|
| - virtual void FinalizeUniqueValueId() {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| if (!has_double_value_ && !has_external_reference_value_) {
|
| ASSERT(!handle_.is_null());
|
| unique_id_ = UniqueValueId(handle_);
|
| @@ -3372,15 +3379,15 @@ class HConstant: public HTemplateInstruction<0> {
|
| }
|
|
|
| #ifdef DEBUG
|
| - virtual void Verify() { }
|
| + virtual void Verify() V8_OVERRIDE { }
|
| #endif
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Constant)
|
|
|
| protected:
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HConstant* other_constant = HConstant::cast(other);
|
| if (has_int32_value_) {
|
| return other_constant->has_int32_value_ &&
|
| @@ -3423,7 +3430,7 @@ class HConstant: public HTemplateInstruction<0> {
|
|
|
| void Initialize(Representation r);
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| // If this is a numerical constant, handle_ either points to to the
|
| // HeapObject the constant originated from or is null. If the
|
| @@ -3451,7 +3458,7 @@ class HConstant: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HBinaryOperation: public HTemplateInstruction<3> {
|
| +class HBinaryOperation : public HTemplateInstruction<3> {
|
| public:
|
| HBinaryOperation(HValue* context, HValue* left, HValue* right,
|
| HType type = HType::Tagged())
|
| @@ -3501,29 +3508,30 @@ class HBinaryOperation: public HTemplateInstruction<3> {
|
| observed_output_representation_ = observed;
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| if (index == 0) return Representation::Tagged();
|
| return observed_input_representation_[index - 1];
|
| }
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| Representation rep = !FLAG_smi_binop && new_rep.IsSmi()
|
| ? Representation::Integer32() : new_rep;
|
| HValue::UpdateRepresentation(rep, h_infer, reason);
|
| }
|
|
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer);
|
| - virtual Representation RepresentationFromInputs();
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE;
|
| Representation RepresentationFromOutput();
|
| - virtual void AssumeRepresentation(Representation r);
|
| + virtual void AssumeRepresentation(Representation r) V8_OVERRIDE;
|
|
|
| virtual bool IsCommutative() const { return false; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0) return Representation::Tagged();
|
| return representation();
|
| }
|
| @@ -3538,20 +3546,20 @@ class HBinaryOperation: public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HWrapReceiver: public HTemplateInstruction<2> {
|
| +class HWrapReceiver V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| HValue* receiver() { return OperandAt(0); }
|
| HValue* function() { return OperandAt(1); }
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(WrapReceiver)
|
|
|
| @@ -3564,7 +3572,7 @@ class HWrapReceiver: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HApplyArguments: public HTemplateInstruction<4> {
|
| +class HApplyArguments V8_FINAL : public HTemplateInstruction<4> {
|
| public:
|
| HApplyArguments(HValue* function,
|
| HValue* receiver,
|
| @@ -3578,7 +3586,7 @@ class HApplyArguments: public HTemplateInstruction<4> {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // The length is untagged, all other inputs are tagged.
|
| return (index == 2)
|
| ? Representation::Integer32()
|
| @@ -3594,20 +3602,20 @@ class HApplyArguments: public HTemplateInstruction<4> {
|
| };
|
|
|
|
|
| -class HArgumentsElements: public HTemplateInstruction<0> {
|
| +class HArgumentsElements V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsElements, bool);
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| bool from_inlined() const { return from_inlined_; }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HArgumentsElements(bool from_inlined) : from_inlined_(from_inlined) {
|
| @@ -3617,24 +3625,24 @@ class HArgumentsElements: public HTemplateInstruction<0> {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| bool from_inlined_;
|
| };
|
|
|
|
|
| -class HArgumentsLength: public HUnaryOperation {
|
| +class HArgumentsLength V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsLength, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| explicit HArgumentsLength(HValue* value) : HUnaryOperation(value) {
|
| @@ -3642,11 +3650,11 @@ class HArgumentsLength: public HUnaryOperation {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HAccessArgumentsAt: public HTemplateInstruction<3> {
|
| +class HAccessArgumentsAt V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HAccessArgumentsAt(HValue* arguments, HValue* length, HValue* index) {
|
| set_representation(Representation::Tagged());
|
| @@ -3656,9 +3664,9 @@ class HAccessArgumentsAt: public HTemplateInstruction<3> {
|
| SetOperandAt(2, index);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // The arguments elements is considered tagged.
|
| return index == 0
|
| ? Representation::Tagged()
|
| @@ -3671,14 +3679,14 @@ class HAccessArgumentsAt: public HTemplateInstruction<3> {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt)
|
|
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| class HBoundsCheckBaseIndexInformation;
|
|
|
|
|
| -class HBoundsCheck: public HTemplateInstruction<2> {
|
| +class HBoundsCheck V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HBoundsCheck, HValue*, HValue*);
|
|
|
| @@ -3707,27 +3715,30 @@ class HBoundsCheck: public HTemplateInstruction<2> {
|
| }
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int arg_index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
|
|
| HValue* index() { return OperandAt(0); }
|
| HValue* length() { return OperandAt(1); }
|
| bool allow_equality() { return allow_equality_; }
|
| void set_allow_equality(bool v) { allow_equality_ = v; }
|
|
|
| - virtual int RedefinedOperandIndex() { return 0; }
|
| - virtual bool IsPurelyInformativeDefinition() { return skip_check(); }
|
| + virtual int RedefinedOperandIndex() V8_OVERRIDE { return 0; }
|
| + virtual bool IsPurelyInformativeDefinition() V8_OVERRIDE {
|
| + return skip_check();
|
| + }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(BoundsCheck)
|
|
|
| protected:
|
| friend class HBoundsCheckBaseIndexInformation;
|
|
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| bool skip_check_;
|
| HValue* base_;
|
| int offset_;
|
| @@ -3749,13 +3760,14 @@ class HBoundsCheck: public HTemplateInstruction<2> {
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return skip_check() && !FLAG_debug_code;
|
| }
|
| };
|
|
|
|
|
| -class HBoundsCheckBaseIndexInformation: public HTemplateInstruction<2> {
|
| +class HBoundsCheckBaseIndexInformation V8_FINAL
|
| + : public HTemplateInstruction<2> {
|
| public:
|
| explicit HBoundsCheckBaseIndexInformation(HBoundsCheck* check) {
|
| DecompositionResult decomposition;
|
| @@ -3772,18 +3784,18 @@ class HBoundsCheckBaseIndexInformation: public HTemplateInstruction<2> {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(BoundsCheckBaseIndexInformation)
|
|
|
| - virtual Representation RequiredInputRepresentation(int arg_index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual int RedefinedOperandIndex() { return 0; }
|
| - virtual bool IsPurelyInformativeDefinition() { return true; }
|
| + virtual int RedefinedOperandIndex() V8_OVERRIDE { return 0; }
|
| + virtual bool IsPurelyInformativeDefinition() V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HBitwiseBinaryOperation: public HBinaryOperation {
|
| +class HBitwiseBinaryOperation : public HBinaryOperation {
|
| public:
|
| HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right,
|
| HType type = HType::Tagged())
|
| @@ -3794,7 +3806,7 @@ class HBitwiseBinaryOperation: public HBinaryOperation {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual void RepresentationChanged(Representation to) {
|
| + virtual void RepresentationChanged(Representation to) V8_OVERRIDE {
|
| if (!to.IsTagged()) {
|
| ASSERT(to.IsSmiOrInteger32());
|
| ClearAllSideEffects();
|
| @@ -3807,13 +3819,13 @@ class HBitwiseBinaryOperation: public HBinaryOperation {
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| // We only generate either int32 or generic tagged bitwise operations.
|
| if (new_rep.IsDouble()) new_rep = Representation::Integer32();
|
| HBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| Representation r = HBinaryOperation::observed_input_representation(index);
|
| if (r.IsDouble()) return Representation::Integer32();
|
| return r;
|
| @@ -3827,11 +3839,11 @@ class HBitwiseBinaryOperation: public HBinaryOperation {
|
| DECLARE_ABSTRACT_INSTRUCTION(BitwiseBinaryOperation)
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HMathFloorOfDiv: public HBinaryOperation {
|
| +class HMathFloorOfDiv V8_FINAL : public HBinaryOperation {
|
| public:
|
| static HMathFloorOfDiv* New(Zone* zone,
|
| HValue* context,
|
| @@ -3840,12 +3852,13 @@ class HMathFloorOfDiv: public HBinaryOperation {
|
| return new(zone) HMathFloorOfDiv(context, left, right);
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HMathFloorOfDiv(HValue* context, HValue* left, HValue* right)
|
| @@ -3859,11 +3872,11 @@ class HMathFloorOfDiv: public HBinaryOperation {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HArithmeticBinaryOperation: public HBinaryOperation {
|
| +class HArithmeticBinaryOperation : public HBinaryOperation {
|
| public:
|
| HArithmeticBinaryOperation(HValue* context, HValue* left, HValue* right)
|
| : HBinaryOperation(context, left, right, HType::TaggedNumber()) {
|
| @@ -3872,7 +3885,7 @@ class HArithmeticBinaryOperation: public HBinaryOperation {
|
| SetFlag(kAllowUndefinedAsNaN);
|
| }
|
|
|
| - virtual void RepresentationChanged(Representation to) {
|
| + virtual void RepresentationChanged(Representation to) V8_OVERRIDE {
|
| if (to.IsTagged()) {
|
| SetAllSideEffects();
|
| ClearFlag(kUseGVN);
|
| @@ -3885,11 +3898,11 @@ class HArithmeticBinaryOperation: public HBinaryOperation {
|
| DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation)
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HCompareGeneric: public HBinaryOperation {
|
| +class HCompareGeneric V8_FINAL : public HBinaryOperation {
|
| public:
|
| HCompareGeneric(HValue* context,
|
| HValue* left,
|
| @@ -3902,14 +3915,14 @@ class HCompareGeneric: public HBinaryOperation {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return index == 0
|
| ? Representation::Tagged()
|
| : representation();
|
| }
|
|
|
| Token::Value token() const { return token_; }
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
|
|
|
| @@ -3918,7 +3931,7 @@ class HCompareGeneric: public HBinaryOperation {
|
| };
|
|
|
|
|
| -class HCompareNumericAndBranch: public HTemplateControlInstruction<2, 2> {
|
| +class HCompareNumericAndBranch : public HTemplateControlInstruction<2, 2> {
|
| public:
|
| HCompareNumericAndBranch(HValue* left, HValue* right, Token::Value token)
|
| : token_(token) {
|
| @@ -3938,15 +3951,16 @@ class HCompareNumericAndBranch: public HTemplateControlInstruction<2, 2> {
|
| observed_input_representation_[1] = right;
|
| }
|
|
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer);
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return observed_input_representation_[index];
|
| }
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch)
|
|
|
| @@ -3956,7 +3970,8 @@ class HCompareNumericAndBranch: public HTemplateControlInstruction<2, 2> {
|
| };
|
|
|
|
|
| -class HCompareHoleAndBranch: public HTemplateControlInstruction<2, 1> {
|
| +class HCompareHoleAndBranch V8_FINAL
|
| + : public HTemplateControlInstruction<2, 1> {
|
| public:
|
| // TODO(danno): make this private when the IfBuilder properly constructs
|
| // control flow instructions.
|
| @@ -3970,19 +3985,20 @@ class HCompareHoleAndBranch: public HTemplateControlInstruction<2, 1> {
|
|
|
| HValue* object() { return OperandAt(0); }
|
|
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer);
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return representation();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CompareHoleAndBranch)
|
| };
|
|
|
|
|
| -class HCompareObjectEqAndBranch: public HTemplateControlInstruction<2, 2> {
|
| +class HCompareObjectEqAndBranch : public HTemplateControlInstruction<2, 2> {
|
| public:
|
| // TODO(danno): make this private when the IfBuilder properly constructs
|
| // control flow instructions.
|
| @@ -3997,13 +4013,13 @@ class HCompareObjectEqAndBranch: public HTemplateControlInstruction<2, 2> {
|
| HValue* left() { return OperandAt(0); }
|
| HValue* right() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4011,24 +4027,24 @@ class HCompareObjectEqAndBranch: public HTemplateControlInstruction<2, 2> {
|
| };
|
|
|
|
|
| -class HIsObjectAndBranch: public HUnaryControlInstruction {
|
| +class HIsObjectAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsObjectAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch)
|
| };
|
|
|
| -class HIsStringAndBranch: public HUnaryControlInstruction {
|
| +class HIsStringAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsStringAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4036,28 +4052,28 @@ class HIsStringAndBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HIsSmiAndBranch: public HUnaryControlInstruction {
|
| +class HIsSmiAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsSmiAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HIsUndetectableAndBranch: public HUnaryControlInstruction {
|
| +class HIsUndetectableAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HIsUndetectableAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4065,7 +4081,7 @@ class HIsUndetectableAndBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HStringCompareAndBranch: public HTemplateControlInstruction<2, 3> {
|
| +class HStringCompareAndBranch : public HTemplateControlInstruction<2, 3> {
|
| public:
|
| HStringCompareAndBranch(HValue* context,
|
| HValue* left,
|
| @@ -4085,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);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4102,9 +4118,9 @@ class HStringCompareAndBranch: public HTemplateControlInstruction<2, 3> {
|
| };
|
|
|
|
|
| -class HIsConstructCallAndBranch: public HTemplateControlInstruction<2, 0> {
|
| +class HIsConstructCallAndBranch : public HTemplateControlInstruction<2, 0> {
|
| public:
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4112,7 +4128,7 @@ class HIsConstructCallAndBranch: public HTemplateControlInstruction<2, 0> {
|
| };
|
|
|
|
|
| -class HHasInstanceTypeAndBranch: public HUnaryControlInstruction {
|
| +class HHasInstanceTypeAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HHasInstanceTypeAndBranch(HValue* value, InstanceType type)
|
| : HUnaryControlInstruction(value, NULL, NULL), from_(type), to_(type) { }
|
| @@ -4124,9 +4140,9 @@ class HHasInstanceTypeAndBranch: public HUnaryControlInstruction {
|
| InstanceType from() { return from_; }
|
| InstanceType to() { return to_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4138,12 +4154,12 @@ class HHasInstanceTypeAndBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HHasCachedArrayIndexAndBranch: public HUnaryControlInstruction {
|
| +class HHasCachedArrayIndexAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| explicit HHasCachedArrayIndexAndBranch(HValue* value)
|
| : HUnaryControlInstruction(value, NULL, NULL) { }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4151,28 +4167,28 @@ class HHasCachedArrayIndexAndBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HGetCachedArrayIndex: public HUnaryOperation {
|
| +class HGetCachedArrayIndex V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HGetCachedArrayIndex(HValue* value) : HUnaryOperation(value) {
|
| set_representation(Representation::Tagged());
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HClassOfTestAndBranch: public HUnaryControlInstruction {
|
| +class HClassOfTestAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HClassOfTestAndBranch(HValue* value, Handle<String> class_name)
|
| : HUnaryControlInstruction(value, NULL, NULL),
|
| @@ -4180,11 +4196,11 @@ class HClassOfTestAndBranch: public HUnaryControlInstruction {
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| Handle<String> class_name() const { return class_name_; }
|
|
|
| @@ -4193,18 +4209,18 @@ class HClassOfTestAndBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HTypeofIsAndBranch: public HUnaryControlInstruction {
|
| +class HTypeofIsAndBranch V8_FINAL : public HUnaryControlInstruction {
|
| public:
|
| HTypeofIsAndBranch(HValue* value, Handle<String> type_literal)
|
| : HUnaryControlInstruction(value, NULL, NULL),
|
| type_literal_(type_literal) { }
|
|
|
| Handle<String> type_literal() { return type_literal_; }
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4213,7 +4229,7 @@ class HTypeofIsAndBranch: public HUnaryControlInstruction {
|
| };
|
|
|
|
|
| -class HInstanceOf: public HBinaryOperation {
|
| +class HInstanceOf V8_FINAL : public HBinaryOperation {
|
| public:
|
| HInstanceOf(HValue* context, HValue* left, HValue* right)
|
| : HBinaryOperation(context, left, right, HType::Boolean()) {
|
| @@ -4221,17 +4237,17 @@ class HInstanceOf: public HBinaryOperation {
|
| SetAllSideEffects();
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(InstanceOf)
|
| };
|
|
|
|
|
| -class HInstanceOfKnownGlobal: public HTemplateInstruction<2> {
|
| +class HInstanceOfKnownGlobal V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HInstanceOfKnownGlobal(HValue* context,
|
| HValue* left,
|
| @@ -4247,7 +4263,7 @@ class HInstanceOfKnownGlobal: public HTemplateInstruction<2> {
|
| HValue* left() { return OperandAt(1); }
|
| Handle<JSFunction> function() { return function_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4261,7 +4277,7 @@ class HInstanceOfKnownGlobal: public HTemplateInstruction<2> {
|
| // TODO(mstarzinger): This instruction should be modeled as a load of the map
|
| // field followed by a load of the instance size field once HLoadNamedField is
|
| // flexible enough to accommodate byte-field loads.
|
| -class HInstanceSize: public HTemplateInstruction<1> {
|
| +class HInstanceSize V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| explicit HInstanceSize(HValue* object) {
|
| SetOperandAt(0, object);
|
| @@ -4270,7 +4286,7 @@ class HInstanceSize: public HTemplateInstruction<1> {
|
|
|
| HValue* object() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -4278,7 +4294,7 @@ class HInstanceSize: public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HPower: public HTemplateInstruction<2> {
|
| +class HPower V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4288,19 +4304,19 @@ class HPower: public HTemplateInstruction<2> {
|
| HValue* left() { return OperandAt(0); }
|
| HValue* right() const { return OperandAt(1); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return index == 0
|
| ? Representation::Double()
|
| : Representation::None();
|
| }
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return RequiredInputRepresentation(index);
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Power)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HPower(HValue* left, HValue* right) {
|
| @@ -4311,13 +4327,13 @@ class HPower: public HTemplateInstruction<2> {
|
| SetGVNFlag(kChangesNewSpacePromotion);
|
| }
|
|
|
| - virtual bool IsDeletable() const {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !right()->representation().IsTagged();
|
| }
|
| };
|
|
|
|
|
| -class HRandom: public HTemplateInstruction<1> {
|
| +class HRandom V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| explicit HRandom(HValue* global_object) {
|
| SetOperandAt(0, global_object);
|
| @@ -4326,18 +4342,18 @@ class HRandom: public HTemplateInstruction<1> {
|
|
|
| HValue* global_object() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Random)
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HAdd: public HArithmeticBinaryOperation {
|
| +class HAdd V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4346,15 +4362,16 @@ class HAdd: public HArithmeticBinaryOperation {
|
|
|
| // Add is only commutative if two integer values are added and not if two
|
| // tagged values are added (because it might be a String concatenation).
|
| - virtual bool IsCommutative() const {
|
| + virtual bool IsCommutative() const V8_OVERRIDE {
|
| return !representation().IsTagged();
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual bool TryDecompose(DecompositionResult* decomposition) {
|
| + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE {
|
| if (left()->IsInteger32Constant()) {
|
| decomposition->Apply(right(), left()->GetInteger32Constant());
|
| return true;
|
| @@ -4366,7 +4383,7 @@ class HAdd: public HArithmeticBinaryOperation {
|
| }
|
| }
|
|
|
| - virtual void RepresentationChanged(Representation to) {
|
| + virtual void RepresentationChanged(Representation to) V8_OVERRIDE {
|
| if (to.IsTagged()) ClearFlag(kAllowUndefinedAsNaN);
|
| HArithmeticBinaryOperation::RepresentationChanged(to);
|
| }
|
| @@ -4374,9 +4391,9 @@ class HAdd: public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Add)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HAdd(HValue* context, HValue* left, HValue* right)
|
| @@ -4386,18 +4403,19 @@ class HAdd: public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HSub: public HArithmeticBinaryOperation {
|
| +class HSub V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| HValue* left,
|
| HValue* right);
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual bool TryDecompose(DecompositionResult* decomposition) {
|
| + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE {
|
| if (right()->IsInteger32Constant()) {
|
| decomposition->Apply(left(), -right()->GetInteger32Constant());
|
| return true;
|
| @@ -4409,9 +4427,9 @@ class HSub: public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Sub)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HSub(HValue* context, HValue* left, HValue* right)
|
| @@ -4421,7 +4439,7 @@ class HSub: public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HMul: public HArithmeticBinaryOperation {
|
| +class HMul V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4439,18 +4457,19 @@ class HMul: public HArithmeticBinaryOperation {
|
| return mul;
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| // Only commutative if it is certain that not two objects are multiplicated.
|
| - virtual bool IsCommutative() const {
|
| + virtual bool IsCommutative() const V8_OVERRIDE {
|
| return !representation().IsTagged();
|
| }
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4458,9 +4477,9 @@ class HMul: public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Mul)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HMul(HValue* context, HValue* left, HValue* right)
|
| @@ -4470,7 +4489,7 @@ class HMul: public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HMod: public HArithmeticBinaryOperation {
|
| +class HMod V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4490,13 +4509,14 @@ class HMod: public HArithmeticBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4504,9 +4524,9 @@ class HMod: public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Mod)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HMod(HValue* context,
|
| @@ -4523,7 +4543,7 @@ class HMod: public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HDiv: public HArithmeticBinaryOperation {
|
| +class HDiv V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4539,13 +4559,14 @@ class HDiv: public HArithmeticBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
|
| + virtual HValue* EnsureAndPropagateNotMinusZero(
|
| + BitVector* visited) V8_OVERRIDE;
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4553,9 +4574,9 @@ class HDiv: public HArithmeticBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Div)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HDiv(HValue* context, HValue* left, HValue* right)
|
| @@ -4566,7 +4587,7 @@ class HDiv: public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HMathMinMax: public HArithmeticBinaryOperation {
|
| +class HMathMinMax V8_FINAL : public HArithmeticBinaryOperation {
|
| public:
|
| enum Operation { kMathMin, kMathMax };
|
|
|
| @@ -4576,18 +4597,14 @@ class HMathMinMax: public HArithmeticBinaryOperation {
|
| HValue* right,
|
| Operation op);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return index == 0 ? Representation::Tagged()
|
| - : representation();
|
| - }
|
| -
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return RequiredInputRepresentation(index);
|
| }
|
|
|
| - virtual void InferRepresentation(HInferRepresentationPhase* h_infer);
|
| + virtual void InferRepresentation(
|
| + HInferRepresentationPhase* h_infer) V8_OVERRIDE;
|
|
|
| - virtual Representation RepresentationFromInputs() {
|
| + virtual Representation RepresentationFromInputs() V8_OVERRIDE {
|
| Representation left_rep = left()->representation();
|
| Representation right_rep = right()->representation();
|
| Representation result = Representation::Smi();
|
| @@ -4597,19 +4614,19 @@ class HMathMinMax: public HArithmeticBinaryOperation {
|
| return result;
|
| }
|
|
|
| - virtual bool IsCommutative() const { return true; }
|
| + virtual bool IsCommutative() const V8_OVERRIDE { return true; }
|
|
|
| Operation operation() { return operation_; }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(MathMinMax)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| return other->IsMathMinMax() &&
|
| HMathMinMax::cast(other)->operation_ == operation_;
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op)
|
| @@ -4620,7 +4637,7 @@ class HMathMinMax: public HArithmeticBinaryOperation {
|
| };
|
|
|
|
|
| -class HBitwise: public HBitwiseBinaryOperation {
|
| +class HBitwise V8_FINAL : public HBitwiseBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -4630,20 +4647,20 @@ class HBitwise: public HBitwiseBinaryOperation {
|
|
|
| Token::Value op() const { return op_; }
|
|
|
| - virtual bool IsCommutative() const { return true; }
|
| + virtual bool IsCommutative() const V8_OVERRIDE { return true; }
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Bitwise)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| return op() == HBitwise::cast(other)->op();
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| private:
|
| HBitwise(HValue* context,
|
| @@ -4680,18 +4697,18 @@ class HBitwise: public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HShl: public HBitwiseBinaryOperation {
|
| +class HShl V8_FINAL : public HBitwiseBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| HValue* left,
|
| HValue* right);
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi() &&
|
| !(right()->IsInteger32Constant() &&
|
| right()->GetInteger32Constant() >= 0)) {
|
| @@ -4703,7 +4720,7 @@ class HShl: public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Shl)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HShl(HValue* context, HValue* left, HValue* right)
|
| @@ -4711,14 +4728,14 @@ class HShl: public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HShr: public HBitwiseBinaryOperation {
|
| +class HShr V8_FINAL : public HBitwiseBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| HValue* left,
|
| HValue* right);
|
|
|
| - virtual bool TryDecompose(DecompositionResult* decomposition) {
|
| + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE {
|
| if (right()->IsInteger32Constant()) {
|
| if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
|
| // This is intended to look for HAdd and HSub, to handle compounds
|
| @@ -4730,11 +4747,11 @@ class HShr: public HBitwiseBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4742,7 +4759,7 @@ class HShr: public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Shr)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HShr(HValue* context, HValue* left, HValue* right)
|
| @@ -4750,14 +4767,14 @@ class HShr: public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HSar: public HBitwiseBinaryOperation {
|
| +class HSar V8_FINAL : public HBitwiseBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| HValue* left,
|
| HValue* right);
|
|
|
| - virtual bool TryDecompose(DecompositionResult* decomposition) {
|
| + virtual bool TryDecompose(DecompositionResult* decomposition) V8_OVERRIDE {
|
| if (right()->IsInteger32Constant()) {
|
| if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
|
| // This is intended to look for HAdd and HSub, to handle compounds
|
| @@ -4769,11 +4786,11 @@ class HSar: public HBitwiseBinaryOperation {
|
| return false;
|
| }
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4781,7 +4798,7 @@ class HSar: public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Sar)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HSar(HValue* context, HValue* left, HValue* right)
|
| @@ -4789,7 +4806,7 @@ class HSar: public HBitwiseBinaryOperation {
|
| };
|
|
|
|
|
| -class HRor: public HBitwiseBinaryOperation {
|
| +class HRor V8_FINAL : public HBitwiseBinaryOperation {
|
| public:
|
| HRor(HValue* context, HValue* left, HValue* right)
|
| : HBitwiseBinaryOperation(context, left, right) {
|
| @@ -4798,7 +4815,7 @@ class HRor: public HBitwiseBinaryOperation {
|
|
|
| virtual void UpdateRepresentation(Representation new_rep,
|
| HInferRepresentationPhase* h_infer,
|
| - const char* reason) {
|
| + const char* reason) V8_OVERRIDE {
|
| if (new_rep.IsSmi()) new_rep = Representation::Integer32();
|
| HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
|
| }
|
| @@ -4806,17 +4823,17 @@ class HRor: public HBitwiseBinaryOperation {
|
| DECLARE_CONCRETE_INSTRUCTION(Ror)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HOsrEntry: public HTemplateInstruction<0> {
|
| +class HOsrEntry V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HOsrEntry, BailoutId);
|
|
|
| BailoutId ast_id() const { return ast_id_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4832,7 +4849,7 @@ class HOsrEntry: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HParameter: public HTemplateInstruction<0> {
|
| +class HParameter V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| enum ParameterKind {
|
| STACK_PARAMETER,
|
| @@ -4847,9 +4864,9 @@ class HParameter: public HTemplateInstruction<0> {
|
| unsigned index() const { return index_; }
|
| ParameterKind kind() const { return kind_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4876,7 +4893,7 @@ class HParameter: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HCallStub: public HUnaryCall {
|
| +class HCallStub V8_FINAL : public HUnaryCall {
|
| public:
|
| HCallStub(HValue* context, CodeStub::Major major_key, int argument_count)
|
| : HUnaryCall(context, argument_count),
|
| @@ -4895,11 +4912,7 @@ class HCallStub: public HUnaryCall {
|
| return transcendental_type_;
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| -
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| - return Representation::Tagged();
|
| - }
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(CallStub)
|
|
|
| @@ -4909,11 +4922,11 @@ class HCallStub: public HUnaryCall {
|
| };
|
|
|
|
|
| -class HUnknownOSRValue: public HTemplateInstruction<0> {
|
| +class HUnknownOSRValue V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P0(HUnknownOSRValue)
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| @@ -4925,7 +4938,7 @@ class HUnknownOSRValue: public HTemplateInstruction<0> {
|
| return incoming_value_;
|
| }
|
|
|
| - virtual Representation KnownOptimalRepresentation() {
|
| + virtual Representation KnownOptimalRepresentation() V8_OVERRIDE {
|
| if (incoming_value_ == NULL) return Representation::None();
|
| return incoming_value_->KnownOptimalRepresentation();
|
| }
|
| @@ -4942,7 +4955,7 @@ class HUnknownOSRValue: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HLoadGlobalCell: public HTemplateInstruction<0> {
|
| +class HLoadGlobalCell V8_FINAL : public HTemplateInstruction<0> {
|
| public:
|
| HLoadGlobalCell(Handle<Cell> cell, PropertyDetails details)
|
| : cell_(cell), details_(details), unique_id_() {
|
| @@ -4954,30 +4967,30 @@ class HLoadGlobalCell: public HTemplateInstruction<0> {
|
| Handle<Cell> cell() const { return cell_; }
|
| bool RequiresHoleCheck() const;
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual intptr_t Hashcode() {
|
| + virtual intptr_t Hashcode() V8_OVERRIDE {
|
| return unique_id_.Hashcode();
|
| }
|
|
|
| - virtual void FinalizeUniqueValueId() {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| unique_id_ = UniqueValueId(cell_);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::None();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HLoadGlobalCell* b = HLoadGlobalCell::cast(other);
|
| return unique_id_ == b->unique_id_;
|
| }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return !RequiresHoleCheck(); }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return !RequiresHoleCheck(); }
|
|
|
| Handle<Cell> cell_;
|
| PropertyDetails details_;
|
| @@ -4985,7 +4998,7 @@ class HLoadGlobalCell: public HTemplateInstruction<0> {
|
| };
|
|
|
|
|
| -class HLoadGlobalGeneric: public HTemplateInstruction<2> {
|
| +class HLoadGlobalGeneric V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HLoadGlobalGeneric(HValue* context,
|
| HValue* global_object,
|
| @@ -5004,9 +5017,9 @@ class HLoadGlobalGeneric: public HTemplateInstruction<2> {
|
| Handle<Object> name() const { return name_; }
|
| bool for_typeof() const { return for_typeof_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -5018,7 +5031,7 @@ class HLoadGlobalGeneric: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HAllocate: public HTemplateInstruction<2> {
|
| +class HAllocate V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HAllocate* New(Zone* zone,
|
| HValue* context,
|
| @@ -5036,7 +5049,7 @@ class HAllocate: public HTemplateInstruction<2> {
|
| HValue* context() { return OperandAt(0); }
|
| HValue* size() { return OperandAt(1); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0) {
|
| return Representation::Tagged();
|
| } else {
|
| @@ -5085,9 +5098,9 @@ class HAllocate: public HTemplateInstruction<2> {
|
| }
|
|
|
| virtual void HandleSideEffectDominator(GVNFlag side_effect,
|
| - HValue* dominator);
|
| + HValue* dominator) V8_OVERRIDE;
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Allocate)
|
|
|
| @@ -5127,7 +5140,7 @@ class HAllocate: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HInnerAllocatedObject: public HTemplateInstruction<1> {
|
| +class HInnerAllocatedObject V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| static HInnerAllocatedObject* New(Zone* zone,
|
| HValue* context,
|
| @@ -5140,11 +5153,11 @@ class HInnerAllocatedObject: public HTemplateInstruction<1> {
|
| HValue* base_object() { return OperandAt(0); }
|
| int offset() { return offset_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject)
|
|
|
| @@ -5191,7 +5204,7 @@ inline bool ReceiverObjectNeedsWriteBarrier(HValue* object,
|
| }
|
|
|
|
|
| -class HStoreGlobalCell: public HUnaryOperation {
|
| +class HStoreGlobalCell V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P3(HStoreGlobalCell, HValue*,
|
| Handle<PropertyCell>, PropertyDetails);
|
| @@ -5204,10 +5217,10 @@ class HStoreGlobalCell: public HUnaryOperation {
|
| return StoringValueNeedsWriteBarrier(value());
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell)
|
|
|
| @@ -5226,7 +5239,7 @@ class HStoreGlobalCell: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HStoreGlobalGeneric: public HTemplateInstruction<3> {
|
| +class HStoreGlobalGeneric : public HTemplateInstruction<3> {
|
| public:
|
| inline static HStoreGlobalGeneric* New(Zone* zone,
|
| HValue* context,
|
| @@ -5244,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);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -5272,7 +5285,7 @@ class HStoreGlobalGeneric: public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HLoadContextSlot: public HUnaryOperation {
|
| +class HLoadContextSlot V8_FINAL : public HUnaryOperation {
|
| public:
|
| enum Mode {
|
| // Perform a normal load of the context slot without checking its value.
|
| @@ -5317,29 +5330,29 @@ class HLoadContextSlot: public HUnaryOperation {
|
| return mode_ != kNoCheck;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HLoadContextSlot* b = HLoadContextSlot::cast(other);
|
| return (slot_index() == b->slot_index());
|
| }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return !RequiresHoleCheck(); }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return !RequiresHoleCheck(); }
|
|
|
| int slot_index_;
|
| Mode mode_;
|
| };
|
|
|
|
|
| -class HStoreContextSlot: public HTemplateInstruction<2> {
|
| +class HStoreContextSlot V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| enum Mode {
|
| // Perform a normal store to the context slot without checking its previous
|
| @@ -5374,11 +5387,11 @@ class HStoreContextSlot: public HTemplateInstruction<2> {
|
| return mode_ != kNoCheck;
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot)
|
|
|
| @@ -5397,7 +5410,7 @@ class HStoreContextSlot: public HTemplateInstruction<2> {
|
|
|
| // Represents an access to a portion of an object, such as the map pointer,
|
| // array elements pointer, etc, but not accesses to array elements themselves.
|
| -class HObjectAccess {
|
| +class HObjectAccess V8_FINAL {
|
| public:
|
| inline bool IsInobject() const {
|
| return portion() != kBackingStore && portion() != kExternalMemory;
|
| @@ -5572,7 +5585,7 @@ class HObjectAccess {
|
| };
|
|
|
|
|
| -class HLoadNamedField: 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,
|
| @@ -5591,21 +5604,21 @@ class HLoadNamedField: public HTemplateInstruction<2> {
|
| return access_.representation();
|
| }
|
|
|
| - virtual bool HasEscapingOperandAt(int index) { return false; }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE { return false; }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0 && access().IsExternalMemory()) {
|
| // object must be external in case of external memory access
|
| return Representation::External();
|
| }
|
| return Representation::Tagged();
|
| }
|
| - virtual Range* InferRange(Zone* zone);
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadNamedField)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HLoadNamedField* b = HLoadNamedField::cast(other);
|
| return access_.Equals(b->access_);
|
| }
|
| @@ -5637,13 +5650,13 @@ class HLoadNamedField: public HTemplateInstruction<2> {
|
| access.SetGVNFlags(this, false);
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| HObjectAccess access_;
|
| };
|
|
|
|
|
| -class HLoadNamedGeneric: public HTemplateInstruction<2> {
|
| +class HLoadNamedGeneric V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HLoadNamedGeneric(HValue* context, HValue* object, Handle<Object> name)
|
| : name_(name) {
|
| @@ -5657,11 +5670,11 @@ class HLoadNamedGeneric: public HTemplateInstruction<2> {
|
| HValue* object() { return OperandAt(1); }
|
| Handle<Object> name() const { return name_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric)
|
|
|
| @@ -5670,7 +5683,7 @@ class HLoadNamedGeneric: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HLoadFunctionPrototype: public HUnaryOperation {
|
| +class HLoadFunctionPrototype V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HLoadFunctionPrototype(HValue* function)
|
| : HUnaryOperation(function) {
|
| @@ -5681,14 +5694,14 @@ class HLoadFunctionPrototype: public HUnaryOperation {
|
|
|
| HValue* function() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
| };
|
|
|
| class ArrayInstructionInterface {
|
| @@ -5713,7 +5726,7 @@ enum LoadKeyedHoleMode {
|
| };
|
|
|
|
|
| -class HLoadKeyed
|
| +class HLoadKeyed V8_FINAL
|
| : public HTemplateInstruction<3>, public ArrayInstructionInterface {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P4(HLoadKeyed, HValue*, HValue*, HValue*,
|
| @@ -5748,7 +5761,7 @@ class HLoadKeyed
|
| return HoleModeField::decode(bit_field_);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // kind_fast: tagged[int32] (none)
|
| // kind_double: tagged[int32] (none)
|
| // kind_external: external[int32] (none)
|
| @@ -5763,22 +5776,22 @@ class HLoadKeyed
|
| return Representation::None();
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| return RequiredInputRepresentation(index);
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| bool UsesMustHandleHole() const;
|
| bool AllUsesCanTreatHoleAsNaN() const;
|
| bool RequiresHoleCheck() const;
|
|
|
| - virtual Range* InferRange(Zone* zone);
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadKeyed)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| if (!other->IsLoadKeyed()) return false;
|
| HLoadKeyed* other_load = HLoadKeyed::cast(other);
|
|
|
| @@ -5838,7 +5851,7 @@ class HLoadKeyed
|
| SetFlag(kUseGVN);
|
| }
|
|
|
| - virtual bool IsDeletable() const {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !RequiresHoleCheck();
|
| }
|
|
|
| @@ -5874,7 +5887,7 @@ class HLoadKeyed
|
| };
|
|
|
|
|
| -class HLoadKeyedGeneric: public HTemplateInstruction<3> {
|
| +class HLoadKeyedGeneric V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HLoadKeyedGeneric(HValue* context, HValue* obj, HValue* key) {
|
| set_representation(Representation::Tagged());
|
| @@ -5888,28 +5901,30 @@ class HLoadKeyedGeneric: public HTemplateInstruction<3> {
|
| HValue* key() { return OperandAt(1); }
|
| HValue* context() { return OperandAt(2); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // tagged[tagged]
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual HValue* Canonicalize();
|
| + virtual HValue* Canonicalize() V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric)
|
| };
|
|
|
|
|
| -class HStoreNamedField: public HTemplateInstruction<3> {
|
| +class HStoreNamedField V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P3(HStoreNamedField, HValue*,
|
| HObjectAccess, HValue*);
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreNamedField)
|
|
|
| - virtual bool HasEscapingOperandAt(int index) { return index == 1; }
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual bool HasEscapingOperandAt(int index) V8_OVERRIDE {
|
| + return index == 1;
|
| + }
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| if (index == 0 && access().IsExternalMemory()) {
|
| // object must be external in case of external memory access
|
| return Representation::External();
|
| @@ -5922,11 +5937,11 @@ class HStoreNamedField: public HTemplateInstruction<3> {
|
| return Representation::Tagged();
|
| }
|
| virtual void HandleSideEffectDominator(GVNFlag side_effect,
|
| - HValue* dominator) {
|
| + HValue* dominator) V8_OVERRIDE {
|
| ASSERT(side_effect == kChangesNewSpacePromotion);
|
| new_space_dominator_ = dominator;
|
| }
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| void SkipWriteBarrier() { write_barrier_mode_ = SKIP_WRITE_BARRIER; }
|
| bool IsSkipWriteBarrier() const {
|
| @@ -6001,7 +6016,7 @@ class HStoreNamedField: public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HStoreNamedGeneric: public HTemplateInstruction<3> {
|
| +class HStoreNamedGeneric V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HStoreNamedGeneric(HValue* context,
|
| HValue* object,
|
| @@ -6022,9 +6037,9 @@ class HStoreNamedGeneric: public HTemplateInstruction<3> {
|
| Handle<String> name() { return name_; }
|
| StrictModeFlag strict_mode_flag() { return strict_mode_flag_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6036,13 +6051,13 @@ class HStoreNamedGeneric: public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HStoreKeyed
|
| +class HStoreKeyed V8_FINAL
|
| : public HTemplateInstruction<3>, public ArrayInstructionInterface {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P4(HStoreKeyed, HValue*, HValue*, HValue*,
|
| ElementsKind);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // kind_fast: tagged[int32] = tagged
|
| // kind_double: tagged[int32] = double
|
| // kind_smi : tagged[int32] = smi
|
| @@ -6072,7 +6087,7 @@ class HStoreKeyed
|
| return IsExternalArrayElementsKind(elements_kind());
|
| }
|
|
|
| - virtual Representation observed_input_representation(int index) {
|
| + virtual Representation observed_input_representation(int index) V8_OVERRIDE {
|
| if (index < 2) return RequiredInputRepresentation(index);
|
| if (IsUninitialized()) {
|
| return Representation::None();
|
| @@ -6113,7 +6128,7 @@ class HStoreKeyed
|
| }
|
|
|
| virtual void HandleSideEffectDominator(GVNFlag side_effect,
|
| - HValue* dominator) {
|
| + HValue* dominator) V8_OVERRIDE {
|
| ASSERT(side_effect == kChangesNewSpacePromotion);
|
| new_space_dominator_ = dominator;
|
| }
|
| @@ -6131,7 +6146,7 @@ class HStoreKeyed
|
|
|
| bool NeedsCanonicalization();
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreKeyed)
|
|
|
| @@ -6177,7 +6192,7 @@ class HStoreKeyed
|
| };
|
|
|
|
|
| -class HStoreKeyedGeneric: public HTemplateInstruction<4> {
|
| +class HStoreKeyedGeneric V8_FINAL : public HTemplateInstruction<4> {
|
| public:
|
| HStoreKeyedGeneric(HValue* context,
|
| HValue* object,
|
| @@ -6198,12 +6213,12 @@ class HStoreKeyedGeneric: public HTemplateInstruction<4> {
|
| HValue* context() { return OperandAt(3); }
|
| StrictModeFlag strict_mode_flag() { return strict_mode_flag_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| // tagged[tagged] = tagged
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric)
|
|
|
| @@ -6212,7 +6227,7 @@ class HStoreKeyedGeneric: public HTemplateInstruction<4> {
|
| };
|
|
|
|
|
| -class HTransitionElementsKind: public HTemplateInstruction<2> {
|
| +class HTransitionElementsKind V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| inline static HTransitionElementsKind* New(Zone* zone,
|
| HValue* context,
|
| @@ -6223,7 +6238,7 @@ class HTransitionElementsKind: public HTemplateInstruction<2> {
|
| original_map, transitioned_map);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6234,9 +6249,9 @@ class HTransitionElementsKind: public HTemplateInstruction<2> {
|
| ElementsKind from_kind() { return from_kind_; }
|
| ElementsKind to_kind() { return to_kind_; }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual void FinalizeUniqueValueId() {
|
| + virtual void FinalizeUniqueValueId() V8_OVERRIDE {
|
| original_map_unique_id_ = UniqueValueId(original_map_);
|
| transitioned_map_unique_id_ = UniqueValueId(transitioned_map_);
|
| }
|
| @@ -6244,7 +6259,7 @@ class HTransitionElementsKind: public HTemplateInstruction<2> {
|
| DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| HTransitionElementsKind* instr = HTransitionElementsKind::cast(other);
|
| return original_map_unique_id_ == instr->original_map_unique_id_ &&
|
| transitioned_map_unique_id_ == instr->transitioned_map_unique_id_;
|
| @@ -6281,7 +6296,7 @@ class HTransitionElementsKind: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HStringAdd: public HBinaryOperation {
|
| +class HStringAdd V8_FINAL : public HBinaryOperation {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| @@ -6291,14 +6306,14 @@ class HStringAdd: public HBinaryOperation {
|
|
|
| StringAddFlags flags() const { return flags_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StringAdd)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| private:
|
| HStringAdd(HValue* context, HValue* left, HValue* right, StringAddFlags flags)
|
| @@ -6311,13 +6326,13 @@ class HStringAdd: public HBinaryOperation {
|
|
|
| // No side-effects except possible allocation.
|
| // NOTE: this instruction _does not_ call ToString() on its inputs.
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| const StringAddFlags flags_;
|
| };
|
|
|
|
|
| -class HStringCharCodeAt: public HTemplateInstruction<3> {
|
| +class HStringCharCodeAt V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| static HStringCharCodeAt* New(Zone* zone,
|
| HValue* context,
|
| @@ -6340,9 +6355,9 @@ class HStringCharCodeAt: public HTemplateInstruction<3> {
|
| DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| - virtual Range* InferRange(Zone* zone) {
|
| + virtual Range* InferRange(Zone* zone) V8_OVERRIDE {
|
| return new(zone) Range(0, String::kMaxUtf16CodeUnit);
|
| }
|
|
|
| @@ -6358,17 +6373,17 @@ class HStringCharCodeAt: public HTemplateInstruction<3> {
|
| }
|
|
|
| // No side effects: runtime function assumes string + number inputs.
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HStringCharFromCode: public HTemplateInstruction<2> {
|
| +class HStringCharFromCode V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HInstruction* New(Zone* zone,
|
| HValue* context,
|
| HValue* char_code);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return index == 0
|
| ? Representation::Tagged()
|
| : Representation::Integer32();
|
| @@ -6377,7 +6392,7 @@ class HStringCharFromCode: public HTemplateInstruction<2> {
|
| HValue* context() const { return OperandAt(0); }
|
| HValue* value() const { return OperandAt(1); }
|
|
|
| - virtual bool DataEquals(HValue* other) { return true; }
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE { return true; }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode)
|
|
|
| @@ -6391,14 +6406,14 @@ class HStringCharFromCode: public HTemplateInstruction<2> {
|
| SetGVNFlag(kChangesNewSpacePromotion);
|
| }
|
|
|
| - virtual bool IsDeletable() const {
|
| + virtual bool IsDeletable() const V8_OVERRIDE {
|
| return !value()->ToNumberCanBeObserved();
|
| }
|
| };
|
|
|
|
|
| template <int V>
|
| -class HMaterializedLiteral: public HTemplateInstruction<V> {
|
| +class HMaterializedLiteral : public HTemplateInstruction<V> {
|
| public:
|
| HMaterializedLiteral<V>(int index, int depth, AllocationSiteMode mode)
|
| : literal_index_(index), depth_(depth), allocation_site_mode_(mode) {
|
| @@ -6418,7 +6433,7 @@ class HMaterializedLiteral: public HTemplateInstruction<V> {
|
| }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_FINAL V8_OVERRIDE { return true; }
|
|
|
| int literal_index_;
|
| int depth_;
|
| @@ -6426,7 +6441,7 @@ class HMaterializedLiteral: public HTemplateInstruction<V> {
|
| };
|
|
|
|
|
| -class HRegExpLiteral: public HMaterializedLiteral<1> {
|
| +class HRegExpLiteral V8_FINAL : public HMaterializedLiteral<1> {
|
| public:
|
| HRegExpLiteral(HValue* context,
|
| Handle<FixedArray> literals,
|
| @@ -6447,7 +6462,7 @@ class HRegExpLiteral: public HMaterializedLiteral<1> {
|
| Handle<String> pattern() { return pattern_; }
|
| Handle<String> flags() { return flags_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6460,7 +6475,7 @@ class HRegExpLiteral: public HMaterializedLiteral<1> {
|
| };
|
|
|
|
|
| -class HFunctionLiteral: public HTemplateInstruction<1> {
|
| +class HFunctionLiteral V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| HFunctionLiteral(HValue* context,
|
| Handle<SharedFunctionInfo> shared,
|
| @@ -6478,7 +6493,7 @@ class HFunctionLiteral: public HTemplateInstruction<1> {
|
|
|
| HValue* context() { return OperandAt(0); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6491,7 +6506,7 @@ class HFunctionLiteral: public HTemplateInstruction<1> {
|
| LanguageMode language_mode() const { return language_mode_; }
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
|
|
| Handle<SharedFunctionInfo> shared_info_;
|
| bool pretenure_ : 1;
|
| @@ -6501,7 +6516,7 @@ class HFunctionLiteral: public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HTypeof: public HTemplateInstruction<2> {
|
| +class HTypeof V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| explicit HTypeof(HValue* context, HValue* value) {
|
| SetOperandAt(0, context);
|
| @@ -6512,24 +6527,24 @@ class HTypeof: public HTemplateInstruction<2> {
|
| HValue* context() { return OperandAt(0); }
|
| HValue* value() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(Typeof)
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HTrapAllocationMemento : public HTemplateInstruction<1> {
|
| +class HTrapAllocationMemento V8_FINAL : public HTemplateInstruction<1> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HTrapAllocationMemento, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6544,11 +6559,11 @@ class HTrapAllocationMemento : public HTemplateInstruction<1> {
|
| };
|
|
|
|
|
| -class HToFastProperties: public HUnaryOperation {
|
| +class HToFastProperties V8_FINAL : public HUnaryOperation {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P1(HToFastProperties, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6570,28 +6585,28 @@ class HToFastProperties: public HUnaryOperation {
|
| #endif
|
| }
|
|
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HValueOf: public HUnaryOperation {
|
| +class HValueOf V8_FINAL : public HUnaryOperation {
|
| public:
|
| explicit HValueOf(HValue* value) : HUnaryOperation(value) {
|
| set_representation(Representation::Tagged());
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(ValueOf)
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
| -class HDateField: public HUnaryOperation {
|
| +class HDateField V8_FINAL : public HUnaryOperation {
|
| public:
|
| HDateField(HValue* date, Smi* index)
|
| : HUnaryOperation(date), index_(index) {
|
| @@ -6600,7 +6615,7 @@ class HDateField: public HUnaryOperation {
|
|
|
| Smi* index() const { return index_; }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6611,7 +6626,7 @@ class HDateField: public HUnaryOperation {
|
| };
|
|
|
|
|
| -class HSeqStringSetChar: public HTemplateInstruction<3> {
|
| +class HSeqStringSetChar V8_FINAL : public HTemplateInstruction<3> {
|
| public:
|
| HSeqStringSetChar(String::Encoding encoding,
|
| HValue* string,
|
| @@ -6628,7 +6643,7 @@ class HSeqStringSetChar: public HTemplateInstruction<3> {
|
| HValue* index() { return OperandAt(1); }
|
| HValue* value() { return OperandAt(2); }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return (index == 0) ? Representation::Tagged()
|
| : Representation::Integer32();
|
| }
|
| @@ -6640,17 +6655,17 @@ class HSeqStringSetChar: public HTemplateInstruction<3> {
|
| };
|
|
|
|
|
| -class HCheckMapValue: public HTemplateInstruction<2> {
|
| +class HCheckMapValue V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P2(HCheckMapValue, HValue*, HValue*);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| @@ -6660,7 +6675,7 @@ class HCheckMapValue: public HTemplateInstruction<2> {
|
| DECLARE_CONCRETE_INSTRUCTION(CheckMapValue)
|
|
|
| protected:
|
| - virtual bool DataEquals(HValue* other) {
|
| + virtual bool DataEquals(HValue* other) V8_OVERRIDE {
|
| return true;
|
| }
|
|
|
| @@ -6677,7 +6692,7 @@ class HCheckMapValue: public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HForInPrepareMap : public HTemplateInstruction<2> {
|
| +class HForInPrepareMap V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| static HForInPrepareMap* New(Zone* zone,
|
| HValue* context,
|
| @@ -6685,16 +6700,16 @@ class HForInPrepareMap : public HTemplateInstruction<2> {
|
| return new(zone) HForInPrepareMap(context, object);
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| HValue* context() { return OperandAt(0); }
|
| HValue* enumerable() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| @@ -6711,11 +6726,11 @@ class HForInPrepareMap : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HForInCacheArray : public HTemplateInstruction<2> {
|
| +class HForInCacheArray V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| DECLARE_INSTRUCTION_FACTORY_P3(HForInCacheArray, HValue*, HValue*, int);
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| @@ -6731,9 +6746,9 @@ class HForInCacheArray : public HTemplateInstruction<2> {
|
| index_cache_ = index_cache;
|
| }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| @@ -6753,7 +6768,7 @@ class HForInCacheArray : public HTemplateInstruction<2> {
|
| };
|
|
|
|
|
| -class HLoadFieldByIndex : public HTemplateInstruction<2> {
|
| +class HLoadFieldByIndex V8_FINAL : public HTemplateInstruction<2> {
|
| public:
|
| HLoadFieldByIndex(HValue* object,
|
| HValue* index) {
|
| @@ -6762,23 +6777,23 @@ class HLoadFieldByIndex : public HTemplateInstruction<2> {
|
| set_representation(Representation::Tagged());
|
| }
|
|
|
| - virtual Representation RequiredInputRepresentation(int index) {
|
| + virtual Representation RequiredInputRepresentation(int index) V8_OVERRIDE {
|
| return Representation::Tagged();
|
| }
|
|
|
| HValue* object() { return OperandAt(0); }
|
| HValue* index() { return OperandAt(1); }
|
|
|
| - virtual void PrintDataTo(StringStream* stream);
|
| + virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
|
|
|
| - virtual HType CalculateInferredType() {
|
| + virtual HType CalculateInferredType() V8_OVERRIDE {
|
| return HType::Tagged();
|
| }
|
|
|
| DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex);
|
|
|
| private:
|
| - virtual bool IsDeletable() const { return true; }
|
| + virtual bool IsDeletable() const V8_OVERRIDE { return true; }
|
| };
|
|
|
|
|
|
|
Chromium Code Reviews
Issue 22796020:
Reland "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