| Index: src/mips/lithium-codegen-mips.cc
 | 
| diff --git a/src/mips/lithium-codegen-mips.cc b/src/mips/lithium-codegen-mips.cc
 | 
| index d1435550ff39b20719b2acae17a988daf598d781..aa56d7298e6900d00241bfceaf808076f6a0e2a1 100644
 | 
| --- a/src/mips/lithium-codegen-mips.cc
 | 
| +++ b/src/mips/lithium-codegen-mips.cc
 | 
| @@ -36,7 +36,7 @@ namespace v8 {
 | 
|  namespace internal {
 | 
|  
 | 
|  
 | 
| -class SafepointGenerator FINAL  : public CallWrapper {
 | 
| +class SafepointGenerator V8_FINAL  : public CallWrapper {
 | 
|   public:
 | 
|    SafepointGenerator(LCodeGen* codegen,
 | 
|                       LPointerMap* pointers,
 | 
| @@ -46,9 +46,9 @@ class SafepointGenerator FINAL  : public CallWrapper {
 | 
|          deopt_mode_(mode) { }
 | 
|    virtual ~SafepointGenerator() {}
 | 
|  
 | 
| -  virtual void BeforeCall(int call_size) const OVERRIDE {}
 | 
| +  virtual void BeforeCall(int call_size) const V8_OVERRIDE {}
 | 
|  
 | 
| -  virtual void AfterCall() const OVERRIDE {
 | 
| +  virtual void AfterCall() const V8_OVERRIDE {
 | 
|      codegen_->RecordSafepoint(pointers_, deopt_mode_);
 | 
|    }
 | 
|  
 | 
| @@ -2605,15 +2605,15 @@ void LCodeGen::DoInstanceOf(LInstanceOf* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
 | 
| -  class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
 | 
| +  class DeferredInstanceOfKnownGlobal V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
 | 
|                                    LInstanceOfKnownGlobal* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|      Label* map_check() { return &map_check_; }
 | 
|  
 | 
|     private:
 | 
| @@ -3599,14 +3599,14 @@ void LCodeGen::EmitIntegerMathAbs(LMathAbs* instr) {
 | 
|  
 | 
|  void LCodeGen::DoMathAbs(LMathAbs* instr) {
 | 
|    // Class for deferred case.
 | 
| -  class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
 | 
| +  class DeferredMathAbsTaggedHeapNumber V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LMathAbs* instr_;
 | 
|    };
 | 
| @@ -3801,12 +3801,12 @@ void LCodeGen::DoPower(LPower* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoRandom(LRandom* instr) {
 | 
| -  class DeferredDoRandom FINAL : public LDeferredCode {
 | 
| +  class DeferredDoRandom V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredDoRandom(LCodeGen* codegen, LRandom* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE { codegen()->DoDeferredRandom(instr_); }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual void Generate() V8_OVERRIDE { codegen()->DoDeferredRandom(instr_); }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LRandom* instr_;
 | 
|    };
 | 
| @@ -4461,14 +4461,14 @@ void LCodeGen::DoStringAdd(LStringAdd* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
 | 
| -  class DeferredStringCharCodeAt FINAL : public LDeferredCode {
 | 
| +  class DeferredStringCharCodeAt V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredStringCharCodeAt(instr_);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LStringCharCodeAt* instr_;
 | 
|    };
 | 
| @@ -4515,14 +4515,14 @@ void LCodeGen::DoDeferredStringCharCodeAt(LStringCharCodeAt* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
 | 
| -  class DeferredStringCharFromCode FINAL : public LDeferredCode {
 | 
| +  class DeferredStringCharFromCode V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredStringCharFromCode(instr_);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LStringCharFromCode* instr_;
 | 
|    };
 | 
| @@ -4608,16 +4608,16 @@ void LCodeGen::DoUint32ToDouble(LUint32ToDouble* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
 | 
| -  class DeferredNumberTagI FINAL : public LDeferredCode {
 | 
| +  class DeferredNumberTagI V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredNumberTagI(instr_,
 | 
|                                        instr_->value(),
 | 
|                                        SIGNED_INT32);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LNumberTagI* instr_;
 | 
|    };
 | 
| @@ -4634,16 +4634,16 @@ void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
 | 
| -  class DeferredNumberTagU FINAL : public LDeferredCode {
 | 
| +  class DeferredNumberTagU V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredNumberTagI(instr_,
 | 
|                                        instr_->value(),
 | 
|                                        UNSIGNED_INT32);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LNumberTagU* instr_;
 | 
|    };
 | 
| @@ -4714,14 +4714,14 @@ void LCodeGen::DoDeferredNumberTagI(LInstruction* instr,
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
 | 
| -  class DeferredNumberTagD FINAL : public LDeferredCode {
 | 
| +  class DeferredNumberTagD V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredNumberTagD(instr_);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LNumberTagD* instr_;
 | 
|    };
 | 
| @@ -4920,12 +4920,14 @@ void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
 | 
| -  class DeferredTaggedToI FINAL : public LDeferredCode {
 | 
| +  class DeferredTaggedToI V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_); }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
| +      codegen()->DoDeferredTaggedToI(instr_);
 | 
| +    }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LTaggedToI* instr_;
 | 
|    };
 | 
| @@ -5138,17 +5140,17 @@ void LCodeGen::DoDeferredInstanceMigration(LCheckMaps* instr, Register object) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
 | 
| -  class DeferredCheckMaps FINAL : public LDeferredCode {
 | 
| +  class DeferredCheckMaps V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
 | 
|          : LDeferredCode(codegen), instr_(instr), object_(object) {
 | 
|        SetExit(check_maps());
 | 
|      }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredInstanceMigration(instr_, object_);
 | 
|      }
 | 
|      Label* check_maps() { return &check_maps_; }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LCheckMaps* instr_;
 | 
|      Label check_maps_;
 | 
| @@ -5237,12 +5239,14 @@ void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoAllocate(LAllocate* instr) {
 | 
| -  class DeferredAllocate FINAL : public LDeferredCode {
 | 
| +  class DeferredAllocate V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
| +      codegen()->DoDeferredAllocate(instr_);
 | 
| +    }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LAllocate* instr_;
 | 
|    };
 | 
| @@ -5639,14 +5643,14 @@ void LCodeGen::DoDeferredStackCheck(LStackCheck* instr) {
 | 
|  
 | 
|  
 | 
|  void LCodeGen::DoStackCheck(LStackCheck* instr) {
 | 
| -  class DeferredStackCheck FINAL : public LDeferredCode {
 | 
| +  class DeferredStackCheck V8_FINAL : public LDeferredCode {
 | 
|     public:
 | 
|      DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
 | 
|          : LDeferredCode(codegen), instr_(instr) { }
 | 
| -    virtual void Generate() OVERRIDE {
 | 
| +    virtual void Generate() V8_OVERRIDE {
 | 
|        codegen()->DoDeferredStackCheck(instr_);
 | 
|      }
 | 
| -    virtual LInstruction* instr() OVERRIDE { return instr_; }
 | 
| +    virtual LInstruction* instr() V8_OVERRIDE { return instr_; }
 | 
|     private:
 | 
|      LStackCheck* instr_;
 | 
|    };
 | 
| 
 |