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