Bug 1119259 - Mark virtual overridden functions as MOZ_OVERRIDE in JS; r=Waldo
☠☠ backed out by 48fa02688a56 ☠ ☠
authorEhsan Akhgari <ehsan@mozilla.com>
Thu, 08 Jan 2015 10:14:24 -0500
changeset 248844 11a02a002dfa28706e4db87af8d3bccf5fbb9e0e
parent 248843 266d204f97bf8096d39c03fe59d2b6ae2ccc647d
child 248845 a0b1e0b8a80a782fafafbdd854edc28b3a6ed01b
push id4489
push userraliiev@mozilla.com
push dateMon, 23 Feb 2015 15:17:55 +0000
treeherdermozilla-beta@fd7c3dc24146 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersWaldo
bugs1119259
milestone37.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1119259 - Mark virtual overridden functions as MOZ_OVERRIDE in JS; r=Waldo
js/src/jit/IonCaches.h
js/src/jit/LIR.h
js/src/jit/MIR.h
js/src/jsapi-tests/testChromeBuffer.cpp
js/src/jsapi-tests/testGCOutOfMemory.cpp
js/src/jsapi-tests/testOOM.cpp
js/src/jsapi-tests/tests.h
js/src/jsproxy.h
js/src/vm/ScopeObject.cpp
--- a/js/src/jit/IonCaches.h
+++ b/js/src/jit/IonCaches.h
@@ -381,27 +381,27 @@ class RepatchIonCache : public IonCache
 
   public:
     RepatchIonCache()
       : initialJump_(),
         lastJump_()
     {
     }
 
-    virtual void reset();
+    virtual void reset() MOZ_OVERRIDE;
 
     // Set the initial jump state of the cache. The initialJump is the inline
     // jump that will point to out-of-line code (such as the slow path, or
     // stubs), and the rejoinLabel is the position that all out-of-line paths
     // will rejoin to.
-    void emitInitialJump(MacroAssembler &masm, AddCacheState &addState);
-    void bindInitialJump(MacroAssembler &masm, AddCacheState &addState);
+    void emitInitialJump(MacroAssembler &masm, AddCacheState &addState) MOZ_OVERRIDE;
+    void bindInitialJump(MacroAssembler &masm, AddCacheState &addState) MOZ_OVERRIDE;
 
     // Update the labels once the code is finalized.
-    void updateBaseAddress(JitCode *code, MacroAssembler &masm);
+    void updateBaseAddress(JitCode *code, MacroAssembler &masm) MOZ_OVERRIDE;
 
     virtual void *rejoinAddress() MOZ_OVERRIDE {
         return rejoinLabel().raw();
     }
 };
 
 //
 // Dispatch caches avoid patching already-running code. Instead, the jump to
@@ -487,24 +487,24 @@ class DispatchIonCache : public IonCache
   public:
     DispatchIonCache()
       : firstStub_(nullptr),
         rejoinLabel_(),
         dispatchLabel_()
     {
     }
 
-    virtual void reset();
-    virtual void initializeAddCacheState(LInstruction *ins, AddCacheState *addState);
+    virtual void reset() MOZ_OVERRIDE;
+    virtual void initializeAddCacheState(LInstruction *ins, AddCacheState *addState) MOZ_OVERRIDE;
 
-    void emitInitialJump(MacroAssembler &masm, AddCacheState &addState);
-    void bindInitialJump(MacroAssembler &masm, AddCacheState &addState);
+    void emitInitialJump(MacroAssembler &masm, AddCacheState &addState) MOZ_OVERRIDE;
+    void bindInitialJump(MacroAssembler &masm, AddCacheState &addState) MOZ_OVERRIDE;
 
     // Fix up the first stub pointer once the code is finalized.
-    void updateBaseAddress(JitCode *code, MacroAssembler &masm);
+    void updateBaseAddress(JitCode *code, MacroAssembler &masm) MOZ_OVERRIDE;
 
     virtual void *rejoinAddress() MOZ_OVERRIDE {
         return rejoinLabel_.raw();
     }
 };
 
 // Define the cache kind and pre-declare data structures used for calling inline
 // caches.
--- a/js/src/jit/LIR.h
+++ b/js/src/jit/LIR.h
@@ -1024,24 +1024,24 @@ class LInstructionHelper : public LInstr
     }
     void setOperand(size_t index, const LAllocation &a) MOZ_FINAL MOZ_OVERRIDE {
         operands_[index] = a;
     }
     void setTemp(size_t index, const LDefinition &a) MOZ_FINAL MOZ_OVERRIDE {
         temps_[index] = a;
     }
 
-    size_t numSuccessors() const {
+    size_t numSuccessors() const MOZ_OVERRIDE {
         return 0;
     }
-    MBasicBlock *getSuccessor(size_t i) const {
+    MBasicBlock *getSuccessor(size_t i) const MOZ_OVERRIDE {
         MOZ_ASSERT(false);
         return nullptr;
     }
-    void setSuccessor(size_t i, MBasicBlock *successor) {
+    void setSuccessor(size_t i, MBasicBlock *successor) MOZ_OVERRIDE {
         MOZ_ASSERT(false);
     }
 
     // Default accessors, assuming a single input and output, respectively.
     const LAllocation *input() {
         MOZ_ASSERT(numOperands() == 1);
         return getOperand(0);
     }
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -421,18 +421,18 @@ class MDefinition : public MNode
 
     virtual Opcode op() const = 0;
     virtual const char *opName() const = 0;
     virtual void accept(MDefinitionVisitor *visitor) = 0;
 
     void printName(FILE *fp) const;
     static void PrintOpcodeName(FILE *fp, Opcode op);
     virtual void printOpcode(FILE *fp) const;
-    void dump(FILE *fp) const;
-    void dump() const;
+    void dump(FILE *fp) const MOZ_OVERRIDE;
+    void dump() const MOZ_OVERRIDE;
     void dumpLocation(FILE *fp) const;
     void dumpLocation() const;
 
     // For LICM.
     virtual bool neverHoist() const { return false; }
 
     // Also for LICM. Test whether this definition is likely to be a call, which
     // would clobber all or many of the floating-point registers, such that
@@ -550,17 +550,17 @@ class MDefinition : public MNode
     // Compute an absolute or symbolic range for the value of this node.
     virtual void computeRange(TempAllocator &alloc) {
     }
 
     // Collect information from the pre-truncated ranges.
     virtual void collectRangeInfoPreTrunc() {
     }
 
-    MNode::Kind kind() const {
+    MNode::Kind kind() const MOZ_OVERRIDE {
         return MNode::Definition;
     }
 
     uint32_t id() const {
         MOZ_ASSERT(block_);
         return id_;
     }
     void setId(uint32_t id) {
@@ -906,36 +906,39 @@ class MInstruction
     }
 
     // Instructions needing to hook into type analysis should return a
     // TypePolicy.
     virtual TypePolicy *typePolicy() = 0;
     virtual MIRType typePolicySpecialization() = 0;
 };
 
-#define INSTRUCTION_HEADER(opcode)                                          \
+#define INSTRUCTION_HEADER_WITHOUT_TYPEPOLICY(opcode)                       \
     static const Opcode classOpcode = MDefinition::Op_##opcode;             \
-    Opcode op() const {                                                     \
+    Opcode op() const MOZ_OVERRIDE {                                        \
         return classOpcode;                                                 \
     }                                                                       \
-    const char *opName() const {                                            \
+    const char *opName() const MOZ_OVERRIDE {                               \
         return #opcode;                                                     \
     }                                                                       \
-    void accept(MDefinitionVisitor *visitor) {                              \
+    void accept(MDefinitionVisitor *visitor) MOZ_OVERRIDE {                 \
         visitor->visit##opcode(this);                                       \
-    }                                                                       \
-    virtual TypePolicy *typePolicy();                                       \
-    virtual MIRType typePolicySpecialization();
+    }
+
+#define INSTRUCTION_HEADER(opcode)                                          \
+    INSTRUCTION_HEADER_WITHOUT_TYPEPOLICY(opcode)                           \
+    virtual TypePolicy *typePolicy() MOZ_OVERRIDE;                          \
+    virtual MIRType typePolicySpecialization() MOZ_OVERRIDE;
 
 #define ALLOW_CLONE(typename)                                               \
-    bool canClone() const {                                                 \
+    bool canClone() const MOZ_OVERRIDE {                                    \
         return true;                                                        \
     }                                                                       \
     MInstruction *clone(TempAllocator &alloc,                               \
-                        const MDefinitionVector &inputs) const {            \
+                        const MDefinitionVector &inputs) const MOZ_OVERRIDE { \
         MInstruction *res = new(alloc) typename(*this);                     \
         for (size_t i = 0; i < numOperands(); i++)                          \
             res->replaceOperand(i, inputs[i]);                              \
         return res;                                                         \
     }
 
 template <size_t Arity>
 class MAryInstruction : public MInstruction
@@ -1206,17 +1209,17 @@ class MNop : public MNullaryInstruction
     }
 
   public:
     INSTRUCTION_HEADER(Nop)
     static MNop *New(TempAllocator &alloc) {
         return new(alloc) MNop();
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     ALLOW_CLONE(MNop)
 };
 
 // Truncation barrier. This is intended for protecting its input against
 // follow-up truncation optimizations.
@@ -1240,23 +1243,23 @@ class MLimitedTruncate
     }
 
   public:
     INSTRUCTION_HEADER(LimitedTruncate)
     static MLimitedTruncate *New(TempAllocator &alloc, MDefinition *input, TruncateKind kind) {
         return new(alloc) MLimitedTruncate(input, kind);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    TruncateKind operandTruncateKind(size_t index) const;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
     TruncateKind truncateKind() const {
         return truncate_;
     }
     void setTruncateKind(TruncateKind kind) {
         truncate_ = kind;
     }
 };
 
@@ -1282,41 +1285,41 @@ class MConstant : public MNullaryInstruc
     const js::Value *vp() const {
         return &value_;
     }
     bool valueToBoolean() const {
         // A hack to avoid this wordy pattern everywhere in the JIT.
         return ToBoolean(HandleValue::fromMarkedLocation(&value_));
     }
 
-    void printOpcode(FILE *fp) const;
-
-    HashNumber valueHash() const;
-    bool congruentTo(const MDefinition *ins) const;
-
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool updateForReplacement(MDefinition *def) {
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
+
+    HashNumber valueHash() const MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
+
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool updateForReplacement(MDefinition *def) MOZ_OVERRIDE {
         MConstant *c = def->toConstant();
         // During constant folding, we don't want to replace a float32
         // value by a double value.
         if (type() == MIRType_Float32)
             return c->type() == MIRType_Float32;
         if (type() == MIRType_Double)
             return c->type() != MIRType_Float32;
         return true;
     }
 
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-
-    bool canProduceFloat32() const;
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+
+    bool canProduceFloat32() const MOZ_OVERRIDE;
 
     ALLOW_CLONE(MConstant)
 };
 
 // Generic constructor of SIMD valuesX4.
 class MSimdValueX4
   : public MQuaternaryInstruction,
     public NoTypePolicy::Data
@@ -1341,29 +1344,29 @@ class MSimdValueX4
     INSTRUCTION_HEADER(SimdValueX4)
 
     static MSimdValueX4 *New(TempAllocator &alloc, MIRType type, MDefinition *x,
                              MDefinition *y, MDefinition *z, MDefinition *w)
     {
         return new(alloc) MSimdValueX4(type, x, y, z, w);
     }
 
-    bool canConsumeFloat32(MUse *use) const {
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE {
         return SimdTypeToScalarType(type()) == MIRType_Float32;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MSimdValueX4)
 };
 
 // Generic constructor of SIMD valuesX4.
 class MSimdSplatX4
   : public MUnaryInstruction,
     public NoTypePolicy::Data
@@ -1383,29 +1386,29 @@ class MSimdSplatX4
   public:
     INSTRUCTION_HEADER(SimdSplatX4)
 
     static MSimdSplatX4 *New(TempAllocator &alloc, MIRType type, MDefinition *v)
     {
         return new(alloc) MSimdSplatX4(type, v);
     }
 
-    bool canConsumeFloat32(MUse *use) const {
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE {
         return SimdTypeToScalarType(type()) == MIRType_Float32;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MSimdSplatX4)
 };
 
 // A constant SIMD value.
 class MSimdConstant
   : public MNullaryInstruction
 {
@@ -1414,32 +1417,32 @@ class MSimdConstant
   protected:
     MSimdConstant(const SimdConstant &v, MIRType type) : value_(v) {
         MOZ_ASSERT(IsSimdType(type));
         setResultType(type);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdConstant);
+    INSTRUCTION_HEADER(SimdConstant)
     static MSimdConstant *New(TempAllocator &alloc, const SimdConstant &v, MIRType type) {
         return new(alloc) MSimdConstant(v, type);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isSimdConstant())
             return false;
         return value() == ins->toSimdConstant()->value();
     }
 
     const SimdConstant &value() const {
         return value_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     ALLOW_CLONE(MSimdConstant)
 };
 
 // Converts all lanes of a given vector into the type of another vector
 class MSimdConvert
@@ -1450,27 +1453,27 @@ class MSimdConvert
       : MUnaryInstruction(obj)
     {
         MOZ_ASSERT(IsSimdType(obj->type()) && fromType == obj->type());
         MOZ_ASSERT(IsSimdType(toType));
         setResultType(toType);
     }
 
   public:
-    INSTRUCTION_HEADER(SimdConvert);
+    INSTRUCTION_HEADER(SimdConvert)
     static MSimdConvert *NewAsmJS(TempAllocator &alloc, MDefinition *obj, MIRType fromType,
                                   MIRType toType)
     {
         return new(alloc) MSimdConvert(obj, fromType, toType);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
     ALLOW_CLONE(MSimdConvert)
 };
 
 // Casts bits of a vector input to another SIMD type (doesn't generate code).
 class MSimdReinterpretCast
   : public MUnaryInstruction,
@@ -1480,27 +1483,27 @@ class MSimdReinterpretCast
       : MUnaryInstruction(obj)
     {
         MOZ_ASSERT(IsSimdType(obj->type()) && fromType == obj->type());
         MOZ_ASSERT(IsSimdType(toType));
         setResultType(toType);
     }
 
   public:
-    INSTRUCTION_HEADER(SimdReinterpretCast);
+    INSTRUCTION_HEADER(SimdReinterpretCast)
     static MSimdReinterpretCast* NewAsmJS(TempAllocator &alloc, MDefinition *obj, MIRType fromType,
                                           MIRType toType)
     {
         return new(alloc) MSimdReinterpretCast(obj, fromType, toType);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
     ALLOW_CLONE(MSimdReinterpretCast)
 };
 
 // Extracts a lane element from a given vector type, given by its lane symbol.
 class MSimdExtractElement
   : public MUnaryInstruction,
@@ -1515,31 +1518,31 @@ class MSimdExtractElement
         MOZ_ASSERT(IsSimdType(obj->type()));
         MOZ_ASSERT(uint32_t(lane) < SimdTypeToLength(obj->type()));
         MOZ_ASSERT(!IsSimdType(type));
         MOZ_ASSERT(SimdTypeToScalarType(obj->type()) == type);
         setResultType(type);
     }
 
   public:
-    INSTRUCTION_HEADER(SimdExtractElement);
+    INSTRUCTION_HEADER(SimdExtractElement)
     static MSimdExtractElement *NewAsmJS(TempAllocator &alloc, MDefinition *obj, MIRType type,
                                          SimdLane lane)
     {
         return new(alloc) MSimdExtractElement(obj, type, lane);
     }
 
     SimdLane lane() const {
         return lane_;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isSimdExtractElement())
             return false;
         const MSimdExtractElement *other = ins->toSimdExtractElement();
         if (other->lane_ != lane_)
             return false;
         return congruentIfOperandsEqual(other);
     }
     ALLOW_CLONE(MSimdExtractElement)
@@ -1577,25 +1580,25 @@ class MSimdInsertElement
     }
     MDefinition *value() {
         return getOperand(1);
     }
     SimdLane lane() const {
         return lane_;
     }
 
-    bool canConsumeFloat32(MUse *use) const {
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE {
         return use == getUseFor(1) && SimdTypeToScalarType(type()) == MIRType_Float32;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return binaryCongruentTo(ins) && lane_ == ins->toSimdInsertElement()->lane();
     }
 
     ALLOW_CLONE(MSimdInsertElement)
 };
 
 // Extracts the sign bits from a given vector, returning an MIRType_Int32.
 class MSimdSignMask
@@ -1607,26 +1610,26 @@ class MSimdSignMask
       : MUnaryInstruction(obj)
     {
         MOZ_ASSERT(IsSimdType(obj->type()));
         setResultType(MIRType_Int32);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdSignMask);
+    INSTRUCTION_HEADER(SimdSignMask)
     static MSimdSignMask *NewAsmJS(TempAllocator &alloc, MDefinition *obj)
     {
         return new(alloc) MSimdSignMask(obj);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isSimdSignMask())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 
     ALLOW_CLONE(MSimdSignMask)
 };
 
@@ -1682,36 +1685,36 @@ class MSimdSwizzle
         MOZ_ASSERT(IsSimdType(obj->type()));
         MOZ_ASSERT(IsSimdType(type));
         MOZ_ASSERT(obj->type() == type);
         setResultType(type);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdSwizzle);
+    INSTRUCTION_HEADER(SimdSwizzle)
 
     static MSimdSwizzle *NewAsmJS(TempAllocator &alloc, MDefinition *obj, MIRType type,
                                   uint32_t laneX, uint32_t laneY, uint32_t laneZ, uint32_t laneW)
     {
         return new(alloc) MSimdSwizzle(obj, type, laneX, laneY, laneZ, laneW);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isSimdSwizzle())
             return false;
         const MSimdSwizzle *other = ins->toSimdSwizzle();
         return sameLanes(other) && congruentIfOperandsEqual(other);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    MDefinition *foldsTo(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MSimdSwizzle)
 };
 
 // Applies a shuffle operation to the inputs, selecting the 2 first lanes of the
 // output from lanes of the first input, and the 2 last lanes of the output from
 // lanes of the second input.
 class MSimdShuffle
@@ -1729,17 +1732,17 @@ class MSimdShuffle
         MOZ_ASSERT(lhs->type() == rhs->type());
         MOZ_ASSERT(IsSimdType(type));
         MOZ_ASSERT(lhs->type() == type);
         setResultType(type);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdShuffle);
+    INSTRUCTION_HEADER(SimdShuffle)
 
     static MInstruction *NewAsmJS(TempAllocator &alloc, MDefinition *lhs, MDefinition *rhs,
                                   MIRType type, uint32_t laneX, uint32_t laneY, uint32_t laneZ,
                                   uint32_t laneW)
     {
         // Swap operands so that new lanes come from LHS in majority.
         // In the balanced case, swap operands if needs be, in order to be able
         // to do only one vshufps on x86.
@@ -1754,24 +1757,24 @@ class MSimdShuffle
 
         // If all lanes come from the same vector, just use swizzle instead.
         if (laneX < 4 && laneY < 4 && laneZ < 4 && laneW < 4)
             return MSimdSwizzle::NewAsmJS(alloc, lhs, type, laneX, laneY, laneZ, laneW);
 
         return new(alloc) MSimdShuffle(lhs, rhs, type, laneX, laneY, laneZ, laneW);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isSimdShuffle())
             return false;
         const MSimdShuffle *other = ins->toSimdShuffle();
         return sameLanes(other) && binaryCongruentTo(other);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     ALLOW_CLONE(MSimdShuffle)
 };
 
 class MSimdUnaryArith
   : public MUnaryInstruction,
@@ -1796,30 +1799,30 @@ class MSimdUnaryArith
         MOZ_ASSERT(IsSimdType(type));
         MOZ_ASSERT(def->type() == type);
         MOZ_ASSERT_IF(type == MIRType_Int32x4, op == neg || op == not_);
         setResultType(type);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdUnaryArith);
+    INSTRUCTION_HEADER(SimdUnaryArith)
     static MSimdUnaryArith *NewAsmJS(TempAllocator &alloc, MDefinition *def,
                                      Operation op, MIRType t)
     {
         return new(alloc) MSimdUnaryArith(def, op, t);
     }
 
     Operation operation() const { return operation_; }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins) && ins->toSimdUnaryArith()->operation() == operation();
     }
 
     ALLOW_CLONE(MSimdUnaryArith);
 };
 
 // Compares each value of a SIMD vector to each corresponding lane's value of
 // another SIMD vector, and returns a int32x4 vector containing the results of
@@ -1862,24 +1865,24 @@ class MSimdBinaryComp
 
         setResultType(MIRType_Int32x4);
         setMovable();
         if (op == equal || op == notEqual)
             setCommutative();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdBinaryComp);
+    INSTRUCTION_HEADER(SimdBinaryComp)
     static MSimdBinaryComp *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right,
                                      Operation op)
     {
         return new(alloc) MSimdBinaryComp(left, right, op);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     Operation operation() const { return operation_; }
     CompareType compareType() const { return compareType_; }
 
     // Swap the operands and reverse the comparison predicate.
     void reverse() {
@@ -1891,17 +1894,17 @@ class MSimdBinaryComp
           case equal:
           case notEqual:
             break;
           default: MOZ_CRASH("Unexpected compare operation");
         }
         swapOperands();
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!binaryCongruentTo(ins))
             return false;
         return operation_ == ins->toSimdBinaryComp()->operation();
     }
 
     ALLOW_CLONE(MSimdBinaryComp)
 };
 
@@ -1947,30 +1950,30 @@ class MSimdBinaryArith
         MOZ_ASSERT(left->type() == type);
         setResultType(type);
         setMovable();
         if (op == Add || op == Mul || op == Min || op == Max)
             setCommutative();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdBinaryArith);
+    INSTRUCTION_HEADER(SimdBinaryArith)
     static MSimdBinaryArith *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right,
                                       Operation op, MIRType t)
     {
         return new(alloc) MSimdBinaryArith(left, right, op, t);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     Operation operation() const { return operation_; }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!binaryCongruentTo(ins))
             return false;
         return operation_ == ins->toSimdBinaryArith()->operation();
     }
 
     ALLOW_CLONE(MSimdBinaryArith)
 };
 
@@ -1995,30 +1998,30 @@ class MSimdBinaryBitwise
         MOZ_ASSERT(left->type() == right->type());
         MOZ_ASSERT(left->type() == type);
         setResultType(type);
         setMovable();
         setCommutative();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdBinaryBitwise);
+    INSTRUCTION_HEADER(SimdBinaryBitwise)
     static MSimdBinaryBitwise *NewAsmJS(TempAllocator &alloc, MDefinition *left,
                                         MDefinition *right, Operation op, MIRType t)
     {
         return new(alloc) MSimdBinaryBitwise(left, right, op, t);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     Operation operation() const { return operation_; }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!binaryCongruentTo(ins))
             return false;
         return operation_ == ins->toSimdBinaryBitwise()->operation();
     }
 
     ALLOW_CLONE(MSimdBinaryBitwise)
 };
 
@@ -2040,30 +2043,30 @@ class MSimdShift
       : MBinaryInstruction(left, right), operation_(op)
     {
         MOZ_ASSERT(left->type() == MIRType_Int32x4 && right->type() == MIRType_Int32);
         setResultType(MIRType_Int32x4);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdShift);
+    INSTRUCTION_HEADER(SimdShift)
     static MSimdShift *NewAsmJS(TempAllocator &alloc, MDefinition *left,
                                 MDefinition *right, Operation op)
     {
         return new(alloc) MSimdShift(left, right, op);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     Operation operation() const { return operation_; }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!binaryCongruentTo(ins))
             return false;
         return operation_ == ins->toSimdShift()->operation();
     }
 
     ALLOW_CLONE(MSimdShift)
 };
 
@@ -2081,36 +2084,36 @@ class MSimdSelect
         MOZ_ASSERT(mask->type() == MIRType_Int32x4);
         MOZ_ASSERT(lhs->type() == rhs->type());
         MOZ_ASSERT(lhs->type() == type);
         setResultType(type);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(SimdSelect);
+    INSTRUCTION_HEADER(SimdSelect)
     static MSimdSelect *NewAsmJS(TempAllocator &alloc, MDefinition *mask, MDefinition *lhs,
                                  MDefinition *rhs, MIRType t, bool isElementWise)
     {
         return new(alloc) MSimdSelect(mask, lhs, rhs, t, isElementWise);
     }
 
     MDefinition *mask() const {
         return getOperand(0);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     bool isElementWise() const {
         return isElementWise_;
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!congruentIfOperandsEqual(ins))
             return false;
         return isElementWise_ == ins->toSimdSelect()->isElementWise();
     }
 
     ALLOW_CLONE(MSimdSelect)
 };
 
@@ -2147,83 +2150,83 @@ class MParameter : public MNullaryInstru
 
   public:
     INSTRUCTION_HEADER(Parameter)
     static MParameter *New(TempAllocator &alloc, int32_t index, types::TemporaryTypeSet *types);
 
     int32_t index() const {
         return index_;
     }
-    void printOpcode(FILE *fp) const;
-
-    HashNumber valueHash() const;
-    bool congruentTo(const MDefinition *ins) const;
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
+
+    HashNumber valueHash() const MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
 };
 
 class MCallee : public MNullaryInstruction
 {
   public:
     MCallee()
     {
         setResultType(MIRType_Object);
         setMovable();
     }
 
   public:
     INSTRUCTION_HEADER(Callee)
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
     static MCallee *New(TempAllocator &alloc) {
         return new(alloc) MCallee();
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MIsConstructing : public MNullaryInstruction
 {
   public:
     MIsConstructing() {
         setResultType(MIRType_Boolean);
         setMovable();
     }
 
   public:
     INSTRUCTION_HEADER(IsConstructing)
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
     static MIsConstructing *New(TempAllocator &alloc) {
         return new(alloc) MIsConstructing();
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MControlInstruction : public MInstruction
 {
   public:
     MControlInstruction()
     { }
 
     virtual size_t numSuccessors() const = 0;
     virtual MBasicBlock *getSuccessor(size_t i) const = 0;
     virtual void replaceSuccessor(size_t i, MBasicBlock *successor) = 0;
 
-    bool isControlInstruction() const {
-        return true;
-    }
-
-    void printOpcode(FILE *fp) const;
+    bool isControlInstruction() const MOZ_OVERRIDE {
+        return true;
+    }
+
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
 };
 
 class MTableSwitch MOZ_FINAL
   : public MControlInstruction,
     public NoFloatPolicy<0>::Data
 {
     // The successors of the tableswitch
     // - First successor = the default case
@@ -2250,47 +2253,47 @@ class MTableSwitch MOZ_FINAL
         blocks_(alloc),
         low_(low),
         high_(high)
     {
         initOperand(0, ins);
     }
 
   protected:
-    MUse *getUseFor(size_t index) {
+    MUse *getUseFor(size_t index) MOZ_OVERRIDE {
         MOZ_ASSERT(index == 0);
         return &operand_;
     }
 
-    const MUse *getUseFor(size_t index) const {
+    const MUse *getUseFor(size_t index) const MOZ_OVERRIDE {
         MOZ_ASSERT(index == 0);
         return &operand_;
     }
 
   public:
     INSTRUCTION_HEADER(TableSwitch)
     static MTableSwitch *New(TempAllocator &alloc, MDefinition *ins, int32_t low, int32_t high);
 
-    size_t numSuccessors() const {
+    size_t numSuccessors() const MOZ_OVERRIDE {
         return successors_.length();
     }
 
     size_t addSuccessor(MBasicBlock *successor) {
         MOZ_ASSERT(successors_.length() < (size_t)(high_ - low_ + 2));
         MOZ_ASSERT(!successors_.empty());
         successors_.append(successor);
         return successors_.length() - 1;
     }
 
-    MBasicBlock *getSuccessor(size_t i) const {
+    MBasicBlock *getSuccessor(size_t i) const MOZ_OVERRIDE {
         MOZ_ASSERT(i < numSuccessors());
         return successors_[i];
     }
 
-    void replaceSuccessor(size_t i, MBasicBlock *successor) {
+    void replaceSuccessor(size_t i, MBasicBlock *successor) MOZ_OVERRIDE {
         MOZ_ASSERT(i < numSuccessors());
         successors_[i] = successor;
     }
 
     MBasicBlock** blocks() {
         return &blocks_[0];
     }
 
@@ -2332,36 +2335,36 @@ class MTableSwitch MOZ_FINAL
         MOZ_ASSERT(i < numBlocks());
         return blocks_[i];
     }
 
     void addBlock(MBasicBlock *block) {
         blocks_.append(block);
     }
 
-    MDefinition *getOperand(size_t index) const {
+    MDefinition *getOperand(size_t index) const MOZ_OVERRIDE {
         MOZ_ASSERT(index == 0);
         return operand_.producer();
     }
 
-    size_t numOperands() const {
+    size_t numOperands() const MOZ_OVERRIDE {
         return 1;
     }
 
     size_t indexOf(const MUse *u) const MOZ_FINAL MOZ_OVERRIDE {
         MOZ_ASSERT(u == getUseFor(0));
         return 0;
     }
 
     void replaceOperand(size_t index, MDefinition *operand) MOZ_FINAL MOZ_OVERRIDE {
         MOZ_ASSERT(index == 0);
         operand_.replaceProducer(operand);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 };
 
 template <size_t Arity, size_t Successors>
 class MAryControlInstruction : public MControlInstruction
 {
     mozilla::Array<MUse, Arity> operands_;
     mozilla::Array<MBasicBlock *, Successors> successors_;
 
@@ -2417,17 +2420,17 @@ class MGoto
 
   public:
     INSTRUCTION_HEADER(Goto)
     static MGoto *New(TempAllocator &alloc, MBasicBlock *target);
 
     MBasicBlock *target() {
         return getSuccessor(0);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 enum BranchDirection {
     FALSE_BRANCH,
     TRUE_BRANCH
 };
@@ -2467,38 +2470,38 @@ class MTest
     }
     MBasicBlock *ifFalse() const {
         return getSuccessor(1);
     }
     MBasicBlock *branchSuccessor(BranchDirection dir) const {
         return (dir == TRUE_BRANCH) ? ifTrue() : ifFalse();
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     // We cache whether our operand might emulate undefined, but we don't want
     // to do that from New() or the constructor, since those can be called on
     // background threads.  So make callers explicitly call it if they want us
     // to check whether the operand might do this.  If this method is never
     // called, we'll assume our operand can emulate undefined.
     void cacheOperandMightEmulateUndefined();
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
     void filtersUndefinedOrNull(bool trueBranch, MDefinition **subject, bool *filtersUndefined,
                                 bool *filtersNull);
 
     void markOperandCantEmulateUndefined() {
         operandMightEmulateUndefined_ = false;
     }
     bool operandMightEmulateUndefined() const {
         return operandMightEmulateUndefined_;
     }
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         return true;
     }
 #endif
 };
 
 // Equivalent to MTest(true, successor, fake), except without the foldsTo
 // method. This allows IonBuilder to insert fake CFG edges to magically protect
 // control flow for try-catch blocks.
@@ -2517,17 +2520,17 @@ class MGotoWithFake
     static MGotoWithFake *New(TempAllocator &alloc, MBasicBlock *successor, MBasicBlock *fake) {
         return new(alloc) MGotoWithFake(successor, fake);
     }
 
     MBasicBlock *target() const {
         return getSuccessor(0);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // Returns from this function to the previous caller.
 class MReturn
   : public MAryControlInstruction<1, 0>,
     public BoxInputsPolicy::Data
@@ -2540,17 +2543,17 @@ class MReturn
     INSTRUCTION_HEADER(Return)
     static MReturn *New(TempAllocator &alloc, MDefinition *ins) {
         return new(alloc) MReturn(ins);
     }
 
     MDefinition *input() const {
         return getOperand(0);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MThrow
   : public MAryControlInstruction<1, 0>,
     public BoxInputsPolicy::Data
 {
@@ -2559,20 +2562,20 @@ class MThrow
     }
 
   public:
     INSTRUCTION_HEADER(Throw)
     static MThrow *New(TempAllocator &alloc, MDefinition *ins) {
         return new(alloc) MThrow(ins);
     }
 
-    virtual AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool possiblyCalls() const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Fabricate a type set containing only the type of the specified object.
 types::TemporaryTypeSet *
 MakeSingletonTypeSet(types::CompilerConstraintList *constraints, JSObject *obj);
 
@@ -2674,22 +2677,22 @@ class MNewArray
     bool shouldUseVM() const;
 
     // NewArray is marked as non-effectful because all our allocations are
     // either lazy when we are using "new Array(length)" or bounded by the
     // script or the stack size when we are using "new Array(...)" or "[...]"
     // notations.  So we might have to allocate the array twice if we bail
     // during the computation of the first element of the square braket
     // notation.
-    virtual AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         // The template object can safely be used in the recover instruction
         // because it can never be mutated by any other function execution.
         return true;
     }
 };
 
 class MNewArrayCopyOnWrite : public MNullaryInstruction
 {
@@ -2720,17 +2723,17 @@ class MNewArrayCopyOnWrite : public MNul
     ArrayObject *templateObject() const {
         return templateObject_;
     }
 
     gc::InitialHeap initialHeap() const {
         return initialHeap_;
     }
 
-    virtual AliasSet getAliasSet() const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MNewArrayDynamicLength
   : public MUnaryInstruction,
     public IntPolicy<0>::Data
 {
@@ -2764,17 +2767,17 @@ class MNewArrayDynamicLength
     }
     ArrayObject *templateObject() const {
         return templateObject_;
     }
     gc::InitialHeap initialHeap() const {
         return initialHeap_;
     }
 
-    virtual AliasSet getAliasSet() const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MNewObject
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -2823,18 +2826,18 @@ class MNewObject
     PlainObject *templateObject() const {
         return &getOperand(0)->toConstant()->value().toObject().as<PlainObject>();
     }
 
     gc::InitialHeap initialHeap() const {
         return initialHeap_;
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         // The template object can safely be used in the recover instruction
         // because it can never be mutated by any other function execution.
         return true;
     }
 };
 
 class MNewTypedObject : public MNullaryInstruction
 {
@@ -2865,17 +2868,17 @@ class MNewTypedObject : public MNullaryI
     InlineTypedObject *templateObject() const {
         return templateObject_;
     }
 
     gc::InitialHeap initialHeap() const {
         return initialHeap_;
     }
 
-    virtual AliasSet getAliasSet() const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MTypedObjectDescr
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
@@ -2892,20 +2895,20 @@ class MTypedObjectDescr
 
     static MTypedObjectDescr *New(TempAllocator &alloc, MDefinition *object) {
         return new(alloc) MTypedObjectDescr(object);
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 };
 
 // Creates a new derived type object. At runtime, this is just a call
 // to `BinaryBlock::createDerived()`. That is, the MIR itself does not
 // compile to particularly optimized code. However, using a distinct
 // MIR for creating derived type objects allows the compiler to
@@ -2933,17 +2936,17 @@ class MNewDerivedTypedObject
       : MTernaryInstruction(type, owner, offset),
         prediction_(prediction)
     {
         setMovable();
         setResultType(MIRType_Object);
     }
 
   public:
-    INSTRUCTION_HEADER(NewDerivedTypedObject);
+    INSTRUCTION_HEADER(NewDerivedTypedObject)
 
     static MNewDerivedTypedObject *New(TempAllocator &alloc, TypedObjectPrediction prediction,
                                        MDefinition *type, MDefinition *owner, MDefinition *offset)
     {
         return new(alloc) MNewDerivedTypedObject(prediction, type, owner, offset);
     }
 
     TypedObjectPrediction prediction() const {
@@ -2957,22 +2960,22 @@ class MNewDerivedTypedObject
     MDefinition *owner() const {
         return getOperand(1);
     }
 
     MDefinition *offset() const {
         return getOperand(2);
     }
 
-    virtual AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Represent the content of all slots of an object.  This instruction is not
 // lowered and is not used to generate code.
 class MObjectState
   : public MVariadicInstruction,
@@ -3025,18 +3028,18 @@ class MObjectState
 
     MDefinition *getDynamicSlot(uint32_t slot) const {
         return getSlot(slot + numFixedSlots());
     }
     void setDynamicSlot(uint32_t slot, MDefinition *def) {
         setSlot(slot + numFixedSlots(), def);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Represent the contents of all elements of an array.  This instruction is not
 // lowered and is not used to generate code.
 class MArrayState
   : public MVariadicInstruction,
@@ -3078,18 +3081,18 @@ class MArrayState
 
     MDefinition *getElement(uint32_t index) const {
         return getOperand(index + 2);
     }
     void setElement(uint32_t index, MDefinition *def) {
         replaceOperand(index + 2, def);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Setting __proto__ in an object literal.
 class MMutateProto
   : public MAryInstruction<2>,
     public MixPolicy<ObjectPolicy<0>, BoxPolicy<1> >::Data
@@ -3112,17 +3115,17 @@ class MMutateProto
 
     MDefinition *getObject() const {
         return getOperand(0);
     }
     MDefinition *getValue() const {
         return getOperand(1);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Slow path for adding a property to an object without a known base.
 class MInitProp
   : public MAryInstruction<2>,
     public MixPolicy<ObjectPolicy<0>, BoxPolicy<1> >::Data
@@ -3153,17 +3156,17 @@ class MInitProp
     }
     MDefinition *getValue() const {
         return getOperand(1);
     }
 
     PropertyName *propertyName() const {
         return name_;
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MInitPropGetterSetter
   : public MBinaryInstruction,
     public MixPolicy<ObjectPolicy<0>, ObjectPolicy<1> >::Data
 {
@@ -3219,17 +3222,17 @@ class MInitElem
         return getOperand(0);
     }
     MDefinition *getId() const {
         return getOperand(1);
     }
     MDefinition *getValue() const {
         return getOperand(2);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MInitElemGetterSetter
   : public MTernaryInstruction,
     public Mix3Policy<ObjectPolicy<0>, BoxPolicy<1>, ObjectPolicy<2> >::Data
 {
@@ -3344,17 +3347,17 @@ class MCall
         return numOperands() - NumNonArgumentOperands;
     }
 
     // Does not include |this|.
     uint32_t numActualArgs() const {
         return numActualArgs_;
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 
     virtual bool isCallDOMNative() const {
         return false;
     }
 
     // A method that can be called to tell the MCall to figure out whether it's
@@ -3427,17 +3430,17 @@ class MArraySplice
     MDefinition *start() const {
         return getOperand(1);
     }
 
     MDefinition *deleteCount() const {
         return getOperand(2);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // fun.apply(self, arguments)
 class MApplyArgs
   : public MAryInstruction<3>,
     public Mix3Policy<ObjectPolicy<0>, IntPolicy<1>, BoxPolicy<2> >::Data
@@ -3470,17 +3473,17 @@ class MApplyArgs
     }
 
     MDefinition *getArgc() const {
         return getOperand(1);
     }
     MDefinition *getThis() const {
         return getOperand(2);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MBail : public MNullaryInstruction
 {
   protected:
     explicit MBail(BailoutKind kind)
@@ -3500,17 +3503,17 @@ class MBail : public MNullaryInstruction
     New(TempAllocator &alloc, BailoutKind kind) {
         return new(alloc) MBail(kind);
     }
     static MBail *
     New(TempAllocator &alloc) {
         return new(alloc) MBail(Bailout_Inevitable);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     BailoutKind bailoutKind() const {
         return bailoutKind_;
     }
 };
 
@@ -3520,17 +3523,17 @@ class MUnreachable
 {
   public:
     INSTRUCTION_HEADER(Unreachable)
 
     static MUnreachable *New(TempAllocator &alloc) {
         return new(alloc) MUnreachable();
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MAssertFloat32
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -3544,17 +3547,17 @@ class MAssertFloat32
 
   public:
     INSTRUCTION_HEADER(AssertFloat32)
 
     static MAssertFloat32 *New(TempAllocator &alloc, MDefinition *value, bool mustBeFloat32) {
         return new(alloc) MAssertFloat32(value, mustBeFloat32);
     }
 
-    bool canConsumeFloat32(MUse *use) const { return true; }
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE { return true; }
 
     bool mustBeFloat32() const { return mustBeFloat32_; }
 };
 
 class MGetDynamicName
   : public MAryInstruction<2>,
     public MixPolicy<ObjectPolicy<0>, ConvertToStringPolicy<1> >::Data
 {
@@ -3575,17 +3578,17 @@ class MGetDynamicName
     }
 
     MDefinition *getScopeChain() const {
         return getOperand(0);
     }
     MDefinition *getName() const {
         return getOperand(1);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Bailout if the input string contains 'arguments' or 'eval'.
 class MFilterArgumentsOrEval
   : public MAryInstruction<1>,
     public BoxExceptPolicy<0, MIRType_String>::Data
@@ -3603,17 +3606,17 @@ class MFilterArgumentsOrEval
 
     static MFilterArgumentsOrEval *New(TempAllocator &alloc, MDefinition *string) {
         return new(alloc) MFilterArgumentsOrEval(string);
     }
 
     MDefinition *getString() const {
         return getOperand(0);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MCallDirectEval
   : public MAryInstruction<3>,
     public Mix3Policy<ObjectPolicy<0>,
                       BoxExceptPolicy<1, MIRType_String>,
@@ -3649,17 +3652,17 @@ class MCallDirectEval
     MDefinition *getThisValue() const {
         return getOperand(2);
     }
 
     jsbytecode  *pc() const {
         return pc_;
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 
   private:
     jsbytecode *pc_;
 };
 
 class MCompare
@@ -3751,17 +3754,17 @@ class MCompare
   public:
     INSTRUCTION_HEADER(Compare)
     static MCompare *New(TempAllocator &alloc, MDefinition *left, MDefinition *right, JSOp op);
     static MCompare *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right, JSOp op,
                               CompareType compareType);
 
     bool tryFold(bool *result);
     bool evaluateConstantOperands(TempAllocator &alloc, bool *result);
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
     void filtersUndefinedOrNull(bool trueBranch, MDefinition **subject, bool *filtersUndefined,
                                 bool *filtersNull);
 
     void infer(BaselineInspector *inspector, jsbytecode *pc);
     CompareType compareType() const {
         return compareType_;
     }
     bool isInt32Comparison() const {
@@ -3795,48 +3798,48 @@ class MCompare
         operandMightEmulateUndefined_ = false;
     }
     bool operandMightEmulateUndefined() const {
         return operandMightEmulateUndefined_;
     }
     bool operandsAreNeverNaN() const {
         return operandsAreNeverNaN_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // Strict equality is never effectful.
         if (jsop_ == JSOP_STRICTEQ || jsop_ == JSOP_STRICTNE)
             return AliasSet::None();
         if (compareType_ == Compare_Unknown)
             return AliasSet::Store(AliasSet::Any);
         MOZ_ASSERT(compareType_ <= Compare_Value);
         return AliasSet::None();
     }
 
-    void printOpcode(FILE *fp) const;
-    void collectRangeInfoPreTrunc();
-
-    void trySpecializeFloat32(TempAllocator &alloc);
-    bool isFloat32Commutative() const { return true; }
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-    TruncateKind operandTruncateKind(size_t index) const;
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
 
 # ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         // Both sides of the compare can be Float32
         return compareType_ == Compare_Float32;
     }
 # endif
 
     ALLOW_CLONE(MCompare)
 
   protected:
     bool tryFoldEqualOperands(bool *result);
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!binaryCongruentTo(ins))
             return false;
         return compareType() == ins->toCompare()->compareType() &&
                jsop() == ins->toCompare()->jsop();
     }
 };
 
 // Takes a typed value and returns an untyped value.
@@ -3864,20 +3867,20 @@ class MBox
     static MBox *New(TempAllocator &alloc, MDefinition *ins)
     {
         // Cannot box a box.
         MOZ_ASSERT(ins->type() != MIRType_Value);
 
         return new(alloc) MBox(alloc, ins);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     ALLOW_CLONE(MBox)
 };
 
 // Note: the op may have been inverted during lowering (to put constants in a
 // position where they can be immediates), so it is important to use the
@@ -3975,25 +3978,25 @@ class MUnbox MOZ_FINAL : public MUnaryIn
     BailoutKind bailoutKind() const {
         // If infallible, no bailout should be generated.
         MOZ_ASSERT(fallible());
         return bailoutKind_;
     }
     bool fallible() const {
         return mode() != Infallible;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isUnbox() || ins->toUnbox()->mode() != mode())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void printOpcode(FILE *fp) const;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
     void makeInfallible() {
         // Should only be called if we're already Infallible or TypeBarrier
         MOZ_ASSERT(mode() != Fallible);
         mode_ = Infallible;
     }
 
     ALLOW_CLONE(MUnbox)
 };
@@ -4011,17 +4014,17 @@ class MGuardObject
     }
 
   public:
     INSTRUCTION_HEADER(GuardObject)
 
     static MGuardObject *New(TempAllocator &alloc, MDefinition *ins) {
         return new(alloc) MGuardObject(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MGuardString
   : public MUnaryInstruction,
     public StringPolicy<0>::Data
 {
@@ -4035,17 +4038,17 @@ class MGuardString
 
   public:
     INSTRUCTION_HEADER(GuardString)
 
     static MGuardString *New(TempAllocator &alloc, MDefinition *ins) {
         return new(alloc) MGuardString(ins);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MAssertRange
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -4068,21 +4071,21 @@ class MAssertRange
     static MAssertRange *New(TempAllocator &alloc, MDefinition *ins, const Range *assertedRange) {
         return new(alloc) MAssertRange(ins, assertedRange);
     }
 
     const Range *assertedRange() const {
         return assertedRange_;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    void printOpcode(FILE *fp) const;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
 };
 
 // Caller-side allocation of |this| for |new|:
 // Given a templateobject, construct |this| for JSOP_NEW
 class MCreateThisWithTemplate
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -4093,39 +4096,39 @@ class MCreateThisWithTemplate
       : MUnaryInstruction(templateConst),
         initialHeap_(initialHeap)
     {
         setResultType(MIRType_Object);
         setResultTypeSet(MakeSingletonTypeSet(constraints, templateObject()));
     }
 
   public:
-    INSTRUCTION_HEADER(CreateThisWithTemplate);
+    INSTRUCTION_HEADER(CreateThisWithTemplate)
     static MCreateThisWithTemplate *New(TempAllocator &alloc, types::CompilerConstraintList *constraints,
                                         MConstant *templateConst, gc::InitialHeap initialHeap)
     {
         return new(alloc) MCreateThisWithTemplate(constraints, templateConst, initialHeap);
     }
 
     // Template for |this|, provided by TI.
     PlainObject *templateObject() const {
         return &getOperand(0)->toConstant()->value().toObject().as<PlainObject>();
     }
 
     gc::InitialHeap initialHeap() const {
         return initialHeap_;
     }
 
     // Although creation of |this| modifies global state, it is safely repeatable.
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE;
 };
 
 // Caller-side allocation of |this| for |new|:
 // Given a prototype operand, construct |this| for JSOP_NEW.
 class MCreateThisWithProto
   : public MBinaryInstruction,
     public MixPolicy<ObjectPolicy<0>, ObjectPolicy<1> >::Data
 {
@@ -4146,20 +4149,20 @@ class MCreateThisWithProto
     MDefinition *getCallee() const {
         return getOperand(0);
     }
     MDefinition *getPrototype() const {
         return getOperand(1);
     }
 
     // Although creation of |this| modifies global state, it is safely repeatable.
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool possiblyCalls() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Caller-side allocation of |this| for |new|:
 // Constructs |this| when possible, else MagicValue(JS_IS_CONSTRUCTING).
 class MCreateThis
   : public MUnaryInstruction,
@@ -4178,20 +4181,20 @@ class MCreateThis
         return new(alloc) MCreateThis(callee);
     }
 
     MDefinition *getCallee() const {
         return getOperand(0);
     }
 
     // Although creation of |this| modifies global state, it is safely repeatable.
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool possiblyCalls() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Eager initialization of arguments object.
 class MCreateArgumentsObject
   : public MUnaryInstruction,
     public ObjectPolicy<0>::Data
@@ -4208,21 +4211,21 @@ class MCreateArgumentsObject
     static MCreateArgumentsObject *New(TempAllocator &alloc, MDefinition *callObj) {
         return new(alloc) MCreateArgumentsObject(callObj);
     }
 
     MDefinition *getCallObject() const {
         return getOperand(0);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool possiblyCalls() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MGetArgumentsObjectArg
   : public MUnaryInstruction,
     public ObjectPolicy<0>::Data
 {
@@ -4245,17 +4248,17 @@ class MGetArgumentsObjectArg
     MDefinition *getArgsObject() const {
         return getOperand(0);
     }
 
     size_t argno() const {
         return argno_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::Any);
     }
 };
 
 class MSetArgumentsObjectArg
   : public MBinaryInstruction,
     public MixPolicy<ObjectPolicy<0>, BoxPolicy<1> >::Data
 {
@@ -4282,17 +4285,17 @@ class MSetArgumentsObjectArg
     size_t argno() const {
         return argno_;
     }
 
     MDefinition *getValue() const {
         return getOperand(1);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::Any);
     }
 };
 
 class MRunOncePrologue
   : public MNullaryInstruction
 {
   protected:
@@ -4302,17 +4305,17 @@ class MRunOncePrologue
     }
 
   public:
     INSTRUCTION_HEADER(RunOncePrologue)
 
     static MRunOncePrologue *New(TempAllocator &alloc) {
         return new(alloc) MRunOncePrologue();
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Given a MIRType_Value A and a MIRType_Object B:
 // If the Value may be safely unboxed to an Object, return Object(A).
 // Otherwise, return B.
 // Used to implement return behavior for inlined constructors.
@@ -4335,17 +4338,17 @@ class MReturnFromCtor
 
     MDefinition *getValue() const {
         return getOperand(0);
     }
     MDefinition *getObject() const {
         return getOperand(1);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MToFPInstruction
   : public MUnaryInstruction,
     public ToDoublePolicy::Data
 {
@@ -4397,44 +4400,44 @@ class MToDouble
                           ConversionKind conversion = NonStringPrimitives)
     {
         return new(alloc) MToDouble(def, conversion);
     }
     static MToDouble *NewAsmJS(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MToDouble(def);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-    bool congruentTo(const MDefinition *ins) const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isToDouble() || ins->toToDouble()->conversion() != conversion())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-    TruncateKind operandTruncateKind(size_t index) const;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
 
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const { return true; }
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE { return true; }
 #endif
 
     TruncateKind truncateKind() const {
         return implicitTruncate_;
     }
     void setTruncateKind(TruncateKind kind) {
         implicitTruncate_ = Max(implicitTruncate_, kind);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         if (input()->type() == MIRType_Value)
             return false;
         if (input()->type() == MIRType_Symbol)
             return false;
 
         return true;
     }
 
@@ -4465,33 +4468,33 @@ class MToFloat32
                            ConversionKind conversion = NonStringPrimitives)
     {
         return new(alloc) MToFloat32(def, conversion);
     }
     static MToFloat32 *NewAsmJS(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MToFloat32(def, NonStringPrimitives);
     }
 
-    virtual MDefinition *foldsTo(TempAllocator &alloc);
-    bool congruentTo(const MDefinition *ins) const {
+    virtual MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isToFloat32() || ins->toToFloat32()->conversion() != conversion())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    void computeRange(TempAllocator &alloc);
-
-    bool canConsumeFloat32(MUse *use) const { return true; }
-    bool canProduceFloat32() const { return true; }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE { return true; }
+    bool canProduceFloat32() const MOZ_OVERRIDE { return true; }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MToFloat32)
 };
 
 // Converts a uint32 to a double (coming from asm.js).
 class MAsmJSUnsignedToDouble
@@ -4501,26 +4504,26 @@ class MAsmJSUnsignedToDouble
     explicit MAsmJSUnsignedToDouble(MDefinition *def)
       : MUnaryInstruction(def)
     {
         setResultType(MIRType_Double);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSUnsignedToDouble);
+    INSTRUCTION_HEADER(AsmJSUnsignedToDouble)
     static MAsmJSUnsignedToDouble *NewAsmJS(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MAsmJSUnsignedToDouble(def);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-    bool congruentTo(const MDefinition *ins) const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // Converts a uint32 to a float32 (coming from asm.js).
 class MAsmJSUnsignedToFloat32
   : public MUnaryInstruction,
     public NoTypePolicy::Data
@@ -4528,30 +4531,30 @@ class MAsmJSUnsignedToFloat32
     explicit MAsmJSUnsignedToFloat32(MDefinition *def)
       : MUnaryInstruction(def)
     {
         setResultType(MIRType_Float32);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSUnsignedToFloat32);
+    INSTRUCTION_HEADER(AsmJSUnsignedToFloat32)
     static MAsmJSUnsignedToFloat32 *NewAsmJS(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MAsmJSUnsignedToFloat32(def);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-    bool congruentTo(const MDefinition *ins) const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool canProduceFloat32() const { return true; }
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool canProduceFloat32() const MOZ_OVERRIDE { return true; }
 };
 
 // Converts a primitive (either typed or untyped) to an int32. If the input is
 // not primitive at runtime, a bailout occurs. If the input cannot be converted
 // to an int32 without loss (i.e. "5.5" or undefined) then a bailout occurs.
 class MToInt32
   : public MUnaryInstruction,
     public ToInt32Policy::Data
@@ -4577,44 +4580,44 @@ class MToInt32
     INSTRUCTION_HEADER(ToInt32)
     static MToInt32 *New(TempAllocator &alloc, MDefinition *def,
                          MacroAssembler::IntConversionInputKind conversion =
                              MacroAssembler::IntConversion_Any)
     {
         return new(alloc) MToInt32(def, conversion);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     // this only has backwards information flow.
-    void analyzeEdgeCasesBackward();
+    void analyzeEdgeCasesBackward() MOZ_OVERRIDE;
 
     bool canBeNegativeZero() const {
         return canBeNegativeZero_;
     }
     void setCanBeNegativeZero(bool negativeZero) {
         canBeNegativeZero_ = negativeZero;
     }
 
     MacroAssembler::IntConversionInputKind conversion() const {
         return conversion_;
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void computeRange(TempAllocator &alloc);
-    void collectRangeInfoPreTrunc();
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
 
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const { return true; }
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE { return true; }
 #endif
 
     ALLOW_CLONE(MToInt32)
 };
 
 // Converts a value or typed input to a truncated int32, for use with bitwise
 // operations. This is an infallible ValueToECMAInt32.
 class MTruncateToInt32
@@ -4637,29 +4640,29 @@ class MTruncateToInt32
     INSTRUCTION_HEADER(TruncateToInt32)
     static MTruncateToInt32 *New(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MTruncateToInt32(def);
     }
     static MTruncateToInt32 *NewAsmJS(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MTruncateToInt32(def);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-
-    bool congruentTo(const MDefinition *ins) const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    void computeRange(TempAllocator &alloc);
-    TruncateKind operandTruncateKind(size_t index) const;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
 # ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         return true;
     }
 #endif
 
     ALLOW_CLONE(MTruncateToInt32)
 };
 
 // Converts any type to a string
@@ -4676,23 +4679,23 @@ class MToString :
 
   public:
     INSTRUCTION_HEADER(ToString)
     static MToString *New(TempAllocator &alloc, MDefinition *def)
     {
         return new(alloc) MToString(def);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-
-    bool congruentTo(const MDefinition *ins) const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     bool fallible() const {
         return input()->mightBeType(MIRType_Object);
     }
 
     ALLOW_CLONE(MToString)
@@ -4712,21 +4715,21 @@ class MToObjectOrNull :
 
   public:
     INSTRUCTION_HEADER(ToObjectOrNull)
     static MToObjectOrNull *New(TempAllocator &alloc, MDefinition *def)
     {
         return new(alloc) MToObjectOrNull(def);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     ALLOW_CLONE(MToObjectOrNull)
 };
 
 class MBitNot
   : public MUnaryInstruction,
@@ -4740,31 +4743,31 @@ class MBitNot
         setMovable();
     }
 
   public:
     INSTRUCTION_HEADER(BitNot)
     static MBitNot *New(TempAllocator &alloc, MDefinition *input);
     static MBitNot *NewAsmJS(TempAllocator &alloc, MDefinition *input);
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
     void infer();
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         if (specialization_ == MIRType_None)
             return AliasSet::Store(AliasSet::Any);
         return AliasSet::None();
     }
-    void computeRange(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ != MIRType_None;
     }
 
     ALLOW_CLONE(MBitNot)
 };
 
 class MTypeOf
   : public MUnaryInstruction,
@@ -4787,45 +4790,45 @@ class MTypeOf
     static MTypeOf *New(TempAllocator &alloc, MDefinition *def, MIRType inputType) {
         return new(alloc) MTypeOf(def, inputType);
     }
 
     MIRType inputType() const {
         return inputType_;
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
     void cacheInputMaybeCallableOrEmulatesUndefined();
 
     bool inputMaybeCallableOrEmulatesUndefined() const {
         return inputMaybeCallableOrEmulatesUndefined_;
     }
     void markInputNotCallableOrEmulatesUndefined() {
         inputMaybeCallableOrEmulatesUndefined_ = false;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isTypeOf())
             return false;
         if (inputType() != ins->toTypeOf()->inputType())
             return false;
         if (inputMaybeCallableOrEmulatesUndefined() !=
             ins->toTypeOf()->inputMaybeCallableOrEmulatesUndefined())
         {
             return false;
         }
         return congruentIfOperandsEqual(ins);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MToId
   : public MBinaryInstruction,
     public BoxInputsPolicy::Data
 {
@@ -4853,59 +4856,59 @@ class MBinaryBitwiseInstruction
     {
         setResultType(MIRType_Int32);
         setMovable();
     }
 
     void specializeAsInt32();
 
   public:
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
     MDefinition *foldUnnecessaryBitop();
     virtual MDefinition *foldIfZero(size_t operand) = 0;
     virtual MDefinition *foldIfNegOne(size_t operand) = 0;
     virtual MDefinition *foldIfEqual()  = 0;
     virtual void infer(BaselineInspector *inspector, jsbytecode *pc);
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return binaryCongruentTo(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         if (specialization_ >= MIRType_Object)
             return AliasSet::Store(AliasSet::Any);
         return AliasSet::None();
     }
 
-    TruncateKind operandTruncateKind(size_t index) const;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
 };
 
 class MBitAnd : public MBinaryBitwiseInstruction
 {
     MBitAnd(MDefinition *left, MDefinition *right)
       : MBinaryBitwiseInstruction(left, right)
     { }
 
   public:
     INSTRUCTION_HEADER(BitAnd)
     static MBitAnd *New(TempAllocator &alloc, MDefinition *left, MDefinition *right);
     static MBitAnd *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right);
 
-    MDefinition *foldIfZero(size_t operand) {
+    MDefinition *foldIfZero(size_t operand) MOZ_OVERRIDE {
         return getOperand(operand); // 0 & x => 0;
     }
-    MDefinition *foldIfNegOne(size_t operand) {
+    MDefinition *foldIfNegOne(size_t operand) MOZ_OVERRIDE {
         return getOperand(1 - operand); // x & -1 => x
     }
-    MDefinition *foldIfEqual() {
+    MDefinition *foldIfEqual() MOZ_OVERRIDE {
         return getOperand(0); // x & x => x;
     }
-    void computeRange(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ != MIRType_None;
     }
 
     ALLOW_CLONE(MBitAnd)
 };
 
 class MBitOr : public MBinaryBitwiseInstruction
 {
@@ -4913,28 +4916,28 @@ class MBitOr : public MBinaryBitwiseInst
       : MBinaryBitwiseInstruction(left, right)
     { }
 
   public:
     INSTRUCTION_HEADER(BitOr)
     static MBitOr *New(TempAllocator &alloc, MDefinition *left, MDefinition *right);
     static MBitOr *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right);
 
-    MDefinition *foldIfZero(size_t operand) {
+    MDefinition *foldIfZero(size_t operand) MOZ_OVERRIDE {
         return getOperand(1 - operand); // 0 | x => x, so if ith is 0, return (1-i)th
     }
-    MDefinition *foldIfNegOne(size_t operand) {
+    MDefinition *foldIfNegOne(size_t operand) MOZ_OVERRIDE {
         return getOperand(operand); // x | -1 => -1
     }
-    MDefinition *foldIfEqual() {
+    MDefinition *foldIfEqual() MOZ_OVERRIDE {
         return getOperand(0); // x | x => x
     }
-    void computeRange(TempAllocator &alloc);
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ != MIRType_None;
     }
 
     ALLOW_CLONE(MBitOr)
 };
 
 class MBitXor : public MBinaryBitwiseInstruction
 {
@@ -4942,73 +4945,73 @@ class MBitXor : public MBinaryBitwiseIns
       : MBinaryBitwiseInstruction(left, right)
     { }
 
   public:
     INSTRUCTION_HEADER(BitXor)
     static MBitXor *New(TempAllocator &alloc, MDefinition *left, MDefinition *right);
     static MBitXor *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right);
 
-    MDefinition *foldIfZero(size_t operand) {
+    MDefinition *foldIfZero(size_t operand) MOZ_OVERRIDE {
         return getOperand(1 - operand); // 0 ^ x => x
     }
-    MDefinition *foldIfNegOne(size_t operand) {
+    MDefinition *foldIfNegOne(size_t operand) MOZ_OVERRIDE {
         return this;
     }
-    MDefinition *foldIfEqual() {
+    MDefinition *foldIfEqual() MOZ_OVERRIDE {
         return this;
     }
-    void computeRange(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     ALLOW_CLONE(MBitXor)
 };
 
 class MShiftInstruction
   : public MBinaryBitwiseInstruction
 {
   protected:
     MShiftInstruction(MDefinition *left, MDefinition *right)
       : MBinaryBitwiseInstruction(left, right)
     { }
 
   public:
-    MDefinition *foldIfNegOne(size_t operand) {
+    MDefinition *foldIfNegOne(size_t operand) MOZ_OVERRIDE {
         return this;
     }
-    MDefinition *foldIfEqual() {
+    MDefinition *foldIfEqual() MOZ_OVERRIDE {
         return this;
     }
-    virtual void infer(BaselineInspector *inspector, jsbytecode *pc);
+    virtual void infer(BaselineInspector *inspector, jsbytecode *pc) MOZ_OVERRIDE;
 };
 
 class MLsh : public MShiftInstruction
 {
     MLsh(MDefinition *left, MDefinition *right)
       : MShiftInstruction(left, right)
     { }
 
   public:
     INSTRUCTION_HEADER(Lsh)
     static MLsh *New(TempAllocator &alloc, MDefinition *left, MDefinition *right);
     static MLsh *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right);
 
-    MDefinition *foldIfZero(size_t operand) {
+    MDefinition *foldIfZero(size_t operand) MOZ_OVERRIDE {
         // 0 << x => 0
         // x << 0 => x
         return getOperand(0);
     }
 
-    void computeRange(TempAllocator &alloc);
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ != MIRType_None;
     }
 
     ALLOW_CLONE(MLsh)
 };
 
 class MRsh : public MShiftInstruction
 {
@@ -5016,25 +5019,25 @@ class MRsh : public MShiftInstruction
       : MShiftInstruction(left, right)
     { }
 
   public:
     INSTRUCTION_HEADER(Rsh)
     static MRsh *New(TempAllocator &alloc, MDefinition *left, MDefinition *right);
     static MRsh *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right);
 
-    MDefinition *foldIfZero(size_t operand) {
+    MDefinition *foldIfZero(size_t operand) MOZ_OVERRIDE {
         // 0 >> x => 0
         // x >> 0 => x
         return getOperand(0);
     }
-    void computeRange(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     ALLOW_CLONE(MRsh)
 };
 
 class MUrsh : public MShiftInstruction
 {
@@ -5045,37 +5048,37 @@ class MUrsh : public MShiftInstruction
         bailoutsDisabled_(false)
     { }
 
   public:
     INSTRUCTION_HEADER(Ursh)
     static MUrsh *New(TempAllocator &alloc, MDefinition *left, MDefinition *right);
     static MUrsh *NewAsmJS(TempAllocator &alloc, MDefinition *left, MDefinition *right);
 
-    MDefinition *foldIfZero(size_t operand) {
+    MDefinition *foldIfZero(size_t operand) MOZ_OVERRIDE {
         // 0 >>> x => 0
         if (operand == 0)
             return getOperand(0);
 
         return this;
     }
 
-    void infer(BaselineInspector *inspector, jsbytecode *pc);
+    void infer(BaselineInspector *inspector, jsbytecode *pc) MOZ_OVERRIDE;
 
     bool bailoutsDisabled() const {
         return bailoutsDisabled_;
     }
 
     bool fallible() const;
 
-    void computeRange(TempAllocator &alloc);
-    void collectRangeInfoPreTrunc();
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     ALLOW_CLONE(MUrsh)
 };
 
 class MBinaryArithInstruction
   : public MBinaryInstruction,
@@ -5096,33 +5099,33 @@ class MBinaryArithInstruction
   public:
     MBinaryArithInstruction(MDefinition *left, MDefinition *right)
       : MBinaryInstruction(left, right),
         implicitTruncate_(NoTruncate)
     {
         setMovable();
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     virtual double getIdentity() = 0;
 
     void infer(TempAllocator &alloc, BaselineInspector *inspector, jsbytecode *pc);
 
     void setInt32() {
         specialization_ = MIRType_Int32;
         setResultType(MIRType_Int32);
     }
 
-    virtual void trySpecializeFloat32(TempAllocator &alloc);
-
-    bool congruentTo(const MDefinition *ins) const {
+    virtual void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return binaryCongruentTo(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         if (specialization_ >= MIRType_Object)
             return AliasSet::Store(AliasSet::Any);
         return AliasSet::None();
     }
 
     bool isTruncated() const {
         return implicitTruncate_ == Truncate;
     }
@@ -5157,36 +5160,36 @@ class MMinMax
     {
         return new(alloc) MMinMax(left, right, type, isMax);
     }
 
     bool isMax() const {
         return isMax_;
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isMinMax())
             return false;
         if (isMax() != ins->toMinMax()->isMax())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    MDefinition *foldsTo(TempAllocator &alloc);
-    void computeRange(TempAllocator &alloc);
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
-        return true;
-    }
-
-    bool isFloat32Commutative() const { return true; }
-    void trySpecializeFloat32(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
+        return true;
+    }
+
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MMinMax)
 };
 
 class MAbs
   : public MUnaryInstruction,
     public ArithPolicy::Data
 {
@@ -5208,30 +5211,30 @@ class MAbs
         return new(alloc) MAbs(num, type);
     }
     static MAbs *NewAsmJS(TempAllocator &alloc, MDefinition *num, MIRType type) {
         MAbs *ins = new(alloc) MAbs(num, type);
         if (type == MIRType_Int32)
             ins->implicitTruncate_ = true;
         return ins;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
     bool fallible() const;
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void computeRange(TempAllocator &alloc);
-    bool isFloat32Commutative() const { return true; }
-    void trySpecializeFloat32(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MAbs)
 };
 
 class MClz
     : public MUnaryInstruction
@@ -5255,31 +5258,31 @@ class MClz
         return new(alloc) MClz(num);
     }
     static MClz *NewAsmJS(TempAllocator &alloc, MDefinition *num) {
         return new(alloc) MClz(num);
     }
     MDefinition *num() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     bool operandIsNeverZero() const {
         return operandIsNeverZero_;
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-    void computeRange(TempAllocator &alloc);
-    void collectRangeInfoPreTrunc();
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
 };
 
 // Inline implementation of Math.sqrt().
 class MSqrt
   : public MUnaryInstruction,
     public FloatingPointPolicy<0>::Data
 {
     MSqrt(MDefinition *num, MIRType type)
@@ -5294,30 +5297,30 @@ class MSqrt
     INSTRUCTION_HEADER(Sqrt)
     static MSqrt *New(TempAllocator &alloc, MDefinition *num) {
         return new(alloc) MSqrt(num, MIRType_Double);
     }
     static MSqrt *NewAsmJS(TempAllocator &alloc, MDefinition *num, MIRType type) {
         MOZ_ASSERT(IsFloatingPointType(type));
         return new(alloc) MSqrt(num, type);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void computeRange(TempAllocator &alloc);
-
-    bool isFloat32Commutative() const { return true; }
-    void trySpecializeFloat32(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MSqrt)
 };
 
 // Inline implementation of atan2 (arctangent of y/x).
 class MAtan2
@@ -5340,30 +5343,30 @@ class MAtan2
     MDefinition *y() const {
         return getOperand(0);
     }
 
     MDefinition *x() const {
         return getOperand(1);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool possiblyCalls() const {
-        return true;
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MAtan2)
 };
 
 // Inline implementation of Math.hypot().
 class MHypot
@@ -5386,30 +5389,30 @@ class MHypot
     MDefinition *x() const {
         return getOperand(0);
     }
 
     MDefinition *y() const {
         return getOperand(1);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool possiblyCalls() const {
-        return true;
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MHypot)
 };
 
 // Inline implementation of Math.pow().
 class MPow
@@ -5434,27 +5437,27 @@ class MPow
     }
 
     MDefinition *input() const {
         return lhs();
     }
     MDefinition *power() const {
         return rhs();
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool possiblyCalls() const {
-        return true;
-    }
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MPow)
 };
 
 // Inline implementation of Math.pow(x, 0.5), which subtly differs from Math.sqrt(x).
 class MPowHalf
@@ -5475,34 +5478,34 @@ class MPowHalf
         setMovable();
     }
 
   public:
     INSTRUCTION_HEADER(PowHalf)
     static MPowHalf *New(TempAllocator &alloc, MDefinition *input) {
         return new(alloc) MPowHalf(input);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
     bool operandIsNeverNegativeInfinity() const {
         return operandIsNeverNegativeInfinity_;
     }
     bool operandIsNeverNegativeZero() const {
         return operandIsNeverNegativeZero_;
     }
     bool operandIsNeverNaN() const {
         return operandIsNeverNaN_;
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void collectRangeInfoPreTrunc();
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MPowHalf)
 };
 
 // Inline implementation of Math.random().
 class MRandom : public MNullaryInstruction
@@ -5513,25 +5516,25 @@ class MRandom : public MNullaryInstructi
     }
 
   public:
     INSTRUCTION_HEADER(Random)
     static MRandom *New(TempAllocator &alloc) {
         return new(alloc) MRandom;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool possiblyCalls() const {
-        return true;
-    }
-
-    void computeRange(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MRandom)
 };
 
 class MMathFunction
   : public MUnaryInstruction,
     public FloatingPointPolicy<0>::Data
 {
@@ -5585,43 +5588,43 @@ class MMathFunction
         return new(alloc) MMathFunction(input, function, cache);
     }
     Function function() const {
         return function_;
     }
     const MathCache *cache() const {
         return cache_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isMathFunction())
             return false;
         if (ins->toMathFunction()->function() != function())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool possiblyCalls() const {
-        return true;
-    }
-
-    void printOpcode(FILE *fp) const;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
 
     static const char *FunctionName(Function function);
 
-    bool isFloat32Commutative() const {
+    bool isFloat32Commutative() const MOZ_OVERRIDE {
         return function_ == Floor || function_ == Ceil || function_ == Round;
     }
-    void trySpecializeFloat32(TempAllocator &alloc);
-    void computeRange(TempAllocator &alloc);
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         switch(function_) {
           case Sin:
           case Round:
             return true;
           default:
             return false;
         }
     }
@@ -5652,30 +5655,30 @@ class MAdd : public MBinaryArithInstruct
         add->setResultType(type);
         if (type == MIRType_Int32) {
             add->setTruncateKind(Truncate);
             add->setCommutative();
         }
         return add;
     }
 
-    bool isFloat32Commutative() const { return true; }
-
-    double getIdentity() {
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
+
+    double getIdentity() MOZ_OVERRIDE {
         return 0;
     }
 
     bool fallible() const;
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-    TruncateKind operandTruncateKind(size_t index) const;
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     ALLOW_CLONE(MAdd)
 };
 
 class MSub : public MBinaryArithInstruction
 {
@@ -5696,30 +5699,30 @@ class MSub : public MBinaryArithInstruct
         MSub *sub = new(alloc) MSub(left, right);
         sub->specialization_ = type;
         sub->setResultType(type);
         if (type == MIRType_Int32)
             sub->setTruncateKind(Truncate);
         return sub;
     }
 
-    double getIdentity() {
+    double getIdentity() MOZ_OVERRIDE {
         return 0;
     }
 
-    bool isFloat32Commutative() const { return true; }
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
 
     bool fallible() const;
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-    TruncateKind operandTruncateKind(size_t index) const;
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     ALLOW_CLONE(MSub)
 };
 
 class MMul : public MBinaryArithInstruction
 {
@@ -5761,26 +5764,26 @@ class MMul : public MBinaryArithInstruct
         return new(alloc) MMul(left, right, MIRType_Value, MMul::Normal);
     }
     static MMul *New(TempAllocator &alloc, MDefinition *left, MDefinition *right, MIRType type,
                      Mode mode = Normal)
     {
         return new(alloc) MMul(left, right, type, mode);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-    void analyzeEdgeCasesForward();
-    void analyzeEdgeCasesBackward();
-    void collectRangeInfoPreTrunc();
-
-    double getIdentity() {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    void analyzeEdgeCasesForward() MOZ_OVERRIDE;
+    void analyzeEdgeCasesBackward() MOZ_OVERRIDE;
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+
+    double getIdentity() MOZ_OVERRIDE {
         return 1;
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isMul())
             return false;
 
         const MMul *mul = ins->toMul();
         if (canBeNegativeZero_ != mul->canBeNegativeZero())
             return false;
 
         if (mode_ != mul->mode())
@@ -5793,37 +5796,37 @@ class MMul : public MBinaryArithInstruct
 
     bool canBeNegativeZero() const {
         return canBeNegativeZero_;
     }
     void setCanBeNegativeZero(bool negativeZero) {
         canBeNegativeZero_ = negativeZero;
     }
 
-    bool updateForReplacement(MDefinition *ins);
+    bool updateForReplacement(MDefinition *ins) MOZ_OVERRIDE;
 
     bool fallible() const {
         return canBeNegativeZero_ || canOverflow();
     }
 
     void setSpecialization(MIRType type) {
         specialization_ = type;
     }
 
-    bool isFloat32Commutative() const { return true; }
-
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-    TruncateKind operandTruncateKind(size_t index) const;
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
 
     Mode mode() const { return mode_; }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     ALLOW_CLONE(MMul)
 };
 
 class MDiv : public MBinaryArithInstruction
 {
@@ -5859,21 +5862,21 @@ class MDiv : public MBinaryArithInstruct
     {
         MDiv *div = new(alloc) MDiv(left, right, type);
         div->unsigned_ = unsignd;
         if (type == MIRType_Int32)
             div->setTruncateKind(Truncate);
         return div;
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-    void analyzeEdgeCasesForward();
-    void analyzeEdgeCasesBackward();
-
-    double getIdentity() {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    void analyzeEdgeCasesForward() MOZ_OVERRIDE;
+    void analyzeEdgeCasesBackward() MOZ_OVERRIDE;
+
+    double getIdentity() MOZ_OVERRIDE {
         MOZ_CRASH("not used");
     }
 
     bool canBeNegativeZero() const {
         return canBeNegativeZero_;
     }
     void setCanBeNegativeZero(bool negativeZero) {
         canBeNegativeZero_ = negativeZero;
@@ -5907,27 +5910,27 @@ class MDiv : public MBinaryArithInstruct
     }
     bool canTruncateOverflow() const {
         return isTruncated() || isTruncatedIndirectly();
     }
     bool canTruncateNegativeZero() const {
         return isTruncated() || isTruncatedIndirectly();
     }
 
-    bool isFloat32Commutative() const { return true; }
-
-    void computeRange(TempAllocator &alloc);
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
     bool fallible() const;
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-    void collectRangeInfoPreTrunc();
-    TruncateKind operandTruncateKind(size_t index) const;
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     ALLOW_CLONE(MDiv)
 };
 
 class MMod : public MBinaryArithInstruction
 {
@@ -5958,19 +5961,19 @@ class MMod : public MBinaryArithInstruct
     {
         MMod *mod = new(alloc) MMod(left, right, type);
         mod->unsigned_ = unsignd;
         if (type == MIRType_Int32)
             mod->setTruncateKind(Truncate);
         return mod;
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-
-    double getIdentity() {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    double getIdentity() MOZ_OVERRIDE {
         MOZ_CRASH("not used");
     }
 
     bool canBeNegativeDividend() const {
         MOZ_ASSERT(specialization_ == MIRType_Int32);
         return canBeNegativeDividend_;
     }
 
@@ -5979,34 +5982,34 @@ class MMod : public MBinaryArithInstruct
         return canBeDivideByZero_;
     }
 
     bool canBePowerOfTwoDivisor() const {
         MOZ_ASSERT(specialization_ == MIRType_Int32);
         return canBePowerOfTwoDivisor_;
     }
 
-    void analyzeEdgeCasesForward();
+    void analyzeEdgeCasesForward() MOZ_OVERRIDE;
 
     bool isUnsigned() const {
         return unsigned_;
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return specialization_ < MIRType_Object;
     }
 
     bool fallible() const;
 
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    void truncate();
-    void collectRangeInfoPreTrunc();
-    TruncateKind operandTruncateKind(size_t index) const;
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
 
     ALLOW_CLONE(MMod)
 };
 
 class MConcat
   : public MBinaryInstruction,
     public MixPolicy<ConvertToStringPolicy<0>, ConvertToStringPolicy<1> >::Data
 {
@@ -6021,25 +6024,25 @@ class MConcat
     }
 
   public:
     INSTRUCTION_HEADER(Concat)
     static MConcat *New(TempAllocator &alloc, MDefinition *left, MDefinition *right) {
         return new(alloc) MConcat(left, right);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MConcat)
 };
 
 class MCharCodeAt
   : public MBinaryInstruction,
@@ -6054,29 +6057,29 @@ class MCharCodeAt
 
   public:
     INSTRUCTION_HEADER(CharCodeAt)
 
     static MCharCodeAt *New(TempAllocator &alloc, MDefinition *str, MDefinition *index) {
         return new(alloc) MCharCodeAt(str, index);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    virtual AliasSet getAliasSet() const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
         // Strings are immutable, so there is no implicit dependency.
         return AliasSet::None();
     }
 
-    void computeRange(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MCharCodeAt)
 };
 
 class MFromCharCode
   : public MUnaryInstruction,
@@ -6091,25 +6094,25 @@ class MFromCharCode
 
   public:
     INSTRUCTION_HEADER(FromCharCode)
 
     static MFromCharCode *New(TempAllocator &alloc, MDefinition *code) {
         return new(alloc) MFromCharCode(code);
     }
 
-    virtual AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool congruentTo(const MDefinition *ins) const {
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MFromCharCode)
 };
 
 class MStringSplit
   : public MTernaryInstruction,
@@ -6139,26 +6142,26 @@ class MStringSplit
         return getOperand(1);
     }
     JSObject *templateObject() const {
         return &getOperand(2)->toConstant()->value().toObject();
     }
     types::TypeObject *typeObject() const {
         return templateObject()->type();
     }
-    bool possiblyCalls() const {
-        return true;
-    }
-    virtual AliasSet getAliasSet() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
         // Although this instruction returns a new array, we don't have to mark
         // it as store instruction, see also MNewArray.
         return AliasSet::None();
     }
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Returns an object to use as |this| value. See also ComputeThis and
 // BoxNonStrictThis in Interpreter.h.
 class MComputeThis
   : public MUnaryInstruction,
@@ -6172,17 +6175,17 @@ class MComputeThis
 
   public:
     INSTRUCTION_HEADER(ComputeThis)
 
     static MComputeThis *New(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MComputeThis(def);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 
     // Note: don't override getAliasSet: the thisObject hook can be
     // effectful.
 };
 
 // Load an arrow function's |this| value.
@@ -6201,20 +6204,20 @@ class MLoadArrowThis
     INSTRUCTION_HEADER(LoadArrowThis)
 
     static MLoadArrowThis *New(TempAllocator &alloc, MDefinition *callee) {
         return new(alloc) MLoadArrowThis(callee);
     }
     MDefinition *callee() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // An arrow function's lexical |this| value is immutable.
         return AliasSet::None();
     }
 };
 
 class MPhi MOZ_FINAL
   : public MDefinition,
     public InlineListNode<MPhi>,
@@ -6229,30 +6232,32 @@ class MPhi MOZ_FINAL
     bool canProduceFloat32_;
     bool canConsumeFloat32_;
 
 #if DEBUG
     bool specialized_;
 #endif
 
   protected:
-    MUse *getUseFor(size_t index) {
+    MUse *getUseFor(size_t index) MOZ_OVERRIDE {
         // Note: after the initial IonBuilder pass, it is OK to change phi
         // operands such that they do not include the type sets of their
         // operands. This can arise during e.g. value numbering, where
         // definitions producing the same value may have different type sets.
         MOZ_ASSERT(index < numOperands());
         return &inputs_[index];
     }
-    const MUse *getUseFor(size_t index) const {
+    const MUse *getUseFor(size_t index) const MOZ_OVERRIDE {
         return &inputs_[index];
     }
 
   public:
-    INSTRUCTION_HEADER(Phi)
+    INSTRUCTION_HEADER_WITHOUT_TYPEPOLICY(Phi)
+    virtual TypePolicy *typePolicy();
+    virtual MIRType typePolicySpecialization();
 
     MPhi(TempAllocator &alloc, MIRType resultType)
       : inputs_(alloc),
         truncateKind_(NoTruncate),
         hasBackedgeType_(false),
         triedToSpecialize_(false),
         isIterator_(false),
         canProduceFloat32_(false),
@@ -6266,20 +6271,20 @@ class MPhi MOZ_FINAL
 
     static MPhi *New(TempAllocator &alloc, MIRType resultType = MIRType_Value) {
         return new(alloc) MPhi(alloc, resultType);
     }
 
     void removeOperand(size_t index);
     void removeAllOperands();
 
-    MDefinition *getOperand(size_t index) const {
+    MDefinition *getOperand(size_t index) const MOZ_OVERRIDE {
         return inputs_[index].producer();
     }
-    size_t numOperands() const {
+    size_t numOperands() const MOZ_OVERRIDE {
         return inputs_.length();
     }
     size_t indexOf(const MUse *u) const MOZ_FINAL MOZ_OVERRIDE {
         MOZ_ASSERT(u >= &inputs_[0]);
         MOZ_ASSERT(u <= &inputs_[numOperands() - 1]);
         return u - &inputs_[0];
     }
     void replaceOperand(size_t index, MDefinition *operand) MOZ_FINAL MOZ_OVERRIDE {
@@ -6354,54 +6359,54 @@ class MPhi MOZ_FINAL
         new (&inputs_.back()) MUse(ins, this);
         return true;
     }
 
     // Update the type of this phi after adding |ins| as an input. Set
     // |*ptypeChange| to true if the type changed.
     bool checkForTypeChange(MDefinition *ins, bool *ptypeChange);
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
     MDefinition *foldsTernary();
 
-    bool congruentTo(const MDefinition *ins) const;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
 
     bool isIterator() const {
         return isIterator_;
     }
     void setIterator() {
         isIterator_ = true;
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void computeRange(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     MDefinition *operandIfRedundant();
 
-    bool canProduceFloat32() const {
+    bool canProduceFloat32() const MOZ_OVERRIDE {
         return canProduceFloat32_;
     }
 
     void setCanProduceFloat32(bool can) {
         canProduceFloat32_ = can;
     }
 
-    bool canConsumeFloat32(MUse *use) const {
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE {
         return canConsumeFloat32_;
     }
 
     void setCanConsumeFloat32(bool can) {
         canConsumeFloat32_ = can;
     }
 
-    TruncateKind operandTruncateKind(size_t index) const;
-    bool needTruncation(TruncateKind kind);
-    void truncate();
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    void truncate() MOZ_OVERRIDE;
 };
 
 // The goal of a Beta node is to split a def at a conditionally taken
 // branch, so that uses dominated by it have a different name.
 class MBeta
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -6417,27 +6422,27 @@ class MBeta
           comparison_(comp)
     {
         setResultType(val->type());
         setResultTypeSet(val->resultTypeSet());
     }
 
   public:
     INSTRUCTION_HEADER(Beta)
-    void printOpcode(FILE *fp) const;
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
     static MBeta *New(TempAllocator &alloc, MDefinition *val, const Range *comp)
     {
         return new(alloc) MBeta(val, comp);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    void computeRange(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 };
 
 // MIR representation of a Value on the OSR BaselineFrame.
 // The Value is indexed off of OsrFrameReg.
 class MOsrValue
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -6460,17 +6465,17 @@ class MOsrValue
     ptrdiff_t frameOffset() const {
         return frameOffset_;
     }
 
     MOsrEntry *entry() {
         return getOperand(0)->toOsrEntry();
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // MIR representation of a JSObject scope chain pointer on the OSR BaselineFrame.
 // The pointer is indexed off of OsrFrameReg.
 class MOsrScopeChain
   : public MUnaryInstruction,
@@ -6562,17 +6567,17 @@ class MInterruptCheck : public MNullaryI
     }
 
   public:
     INSTRUCTION_HEADER(InterruptCheck)
 
     static MInterruptCheck *New(TempAllocator &alloc) {
         return new(alloc) MInterruptCheck();
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // Check whether we need to fire the interrupt handler at loop headers and
 // function prologues in asm.js. Generated only if we can't use implicit
 // interrupt checks with signal handlers.
 class MAsmJSInterruptCheck
@@ -6616,17 +6621,17 @@ class MLexicalCheck
 
   public:
     INSTRUCTION_HEADER(LexicalCheck)
 
     static MLexicalCheck *New(TempAllocator &alloc, MDefinition *input) {
         return new(alloc) MLexicalCheck(input);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     MDefinition *input() const {
         return getOperand(0);
     }
 };
 
@@ -6640,17 +6645,17 @@ class MThrowUninitializedLexical : publi
 
   public:
     INSTRUCTION_HEADER(ThrowUninitializedLexical)
 
     static MThrowUninitializedLexical *New(TempAllocator &alloc) {
         return new(alloc) MThrowUninitializedLexical();
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // If not defined, set a global variable to |undefined|.
 class MDefVar
   : public MUnaryInstruction,
     public NoTypePolicy::Data
@@ -6679,17 +6684,17 @@ class MDefVar
         return name_;
     }
     unsigned attrs() const {
         return attrs_;
     }
     MDefinition *scopeChain() const {
         return getOperand(0);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MDefFun
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -6709,17 +6714,17 @@ class MDefFun
     }
 
     JSFunction *fun() const {
         return fun_;
     }
     MDefinition *scopeChain() const {
         return getOperand(0);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MRegExp : public MNullaryInstruction
 {
     AlwaysTenured<RegExpObject *> source_;
     bool mustClone_;
@@ -6742,20 +6747,20 @@ class MRegExp : public MNullaryInstructi
     }
 
     bool mustClone() const {
         return mustClone_;
     }
     RegExpObject *source() const {
         return source_;
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool possiblyCalls() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MRegExpExec
   : public MBinaryInstruction,
     public MixPolicy<ConvertToStringPolicy<0>, ObjectPolicy<1> >::Data
 {
@@ -6778,25 +6783,25 @@ class MRegExpExec
     MDefinition *string() const {
         return getOperand(0);
     }
 
     MDefinition *regexp() const {
         return getOperand(1);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         if (regexp()->isRegExp())
             return !regexp()->toRegExp()->source()->needUpdateLastIndex();
         return false;
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MRegExpTest
   : public MBinaryInstruction,
     public MixPolicy<ObjectPolicy<1>, ConvertToStringPolicy<0> >::Data
 {
@@ -6817,22 +6822,22 @@ class MRegExpTest
 
     MDefinition *string() const {
         return getOperand(0);
     }
     MDefinition *regexp() const {
         return getOperand(1);
     }
 
-    bool possiblyCalls() const {
-        return true;
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         // RegExpTest has a side-effect on the regexp object's lastIndex
         // when sticky or global flags are set.
         // Return false unless we are sure it's not the case.
         if (regexp()->isRegExp())
             return !regexp()->toRegExp()->source()->needUpdateLastIndex();
         return false;
     }
 };
@@ -6858,40 +6863,40 @@ class MStrReplace
     }
     MDefinition *pattern() const {
         return getOperand(1);
     }
     MDefinition *replacement() const {
         return getOperand(2);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MRegExpReplace
   : public MStrReplace< ObjectPolicy<1> >
 {
   private:
 
     MRegExpReplace(MDefinition *string, MDefinition *pattern, MDefinition *replacement)
       : MStrReplace< ObjectPolicy<1> >(string, pattern, replacement)
     {
     }
 
   public:
-    INSTRUCTION_HEADER(RegExpReplace);
+    INSTRUCTION_HEADER(RegExpReplace)
 
     static MRegExpReplace *New(TempAllocator &alloc, MDefinition *string, MDefinition *pattern, MDefinition *replacement) {
         return new(alloc) MRegExpReplace(string, pattern, replacement);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         // RegExpReplace will zero the lastIndex field when global flag is set.
         // So we can only remove this if it's non-global.
         if (pattern()->isRegExp())
             return !pattern()->toRegExp()->source()->global();
         return false;
     }
 };
 
@@ -6901,32 +6906,32 @@ class MStringReplace
   private:
 
     MStringReplace(MDefinition *string, MDefinition *pattern, MDefinition *replacement)
       : MStrReplace< StringPolicy<1> >(string, pattern, replacement)
     {
     }
 
   public:
-    INSTRUCTION_HEADER(StringReplace);
+    INSTRUCTION_HEADER(StringReplace)
 
     static MStringReplace *New(TempAllocator &alloc, MDefinition *string, MDefinition *pattern, MDefinition *replacement) {
         return new(alloc) MStringReplace(string, pattern, replacement);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         if (pattern()->isRegExp())
             return !pattern()->toRegExp()->source()->global();
         return false;
     }
 };
 
 class MSubstr
   : public MTernaryInstruction,
@@ -6936,17 +6941,17 @@ class MSubstr
 
     MSubstr(MDefinition *string, MDefinition *begin, MDefinition *length)
       : MTernaryInstruction(string, begin, length)
     {
         setResultType(MIRType_String);
     }
 
   public:
-    INSTRUCTION_HEADER(Substr);
+    INSTRUCTION_HEADER(Substr)
 
     static MSubstr *New(TempAllocator &alloc, MDefinition *string, MDefinition *begin,
                         MDefinition *length)
     {
         return new(alloc) MSubstr(string, begin, length);
     }
 
     MDefinition *string() {
@@ -6956,20 +6961,20 @@ class MSubstr
     MDefinition *begin() {
         return getOperand(1);
     }
 
     MDefinition *length() {
         return getOperand(2);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 struct LambdaFunctionInfo
 {
     // The functions used in lambdas are the canonical original function in
     // the script, and are immutable except for delazification. Record this
@@ -7023,18 +7028,18 @@ class MLambda
         return getOperand(0);
     }
     MConstant *functionOperand() const {
         return getOperand(1)->toConstant();
     }
     const LambdaFunctionInfo &info() const {
         return info_;
     }
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MLambdaArrow
   : public MBinaryInstruction,
     public MixPolicy<ObjectPolicy<0>, BoxPolicy<1> >::Data
 {
@@ -7086,20 +7091,20 @@ class MSlots
 
     static MSlots *New(TempAllocator &alloc, MDefinition *object) {
         return new(alloc) MSlots(object);
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 
     ALLOW_CLONE(MSlots)
 };
 
 // Returns obj->elements.
 class MElements
@@ -7118,20 +7123,20 @@ class MElements
 
     static MElements *New(TempAllocator &alloc, MDefinition *object) {
         return new(alloc) MElements(object);
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 
     ALLOW_CLONE(MElements)
 };
 
 // A constant value for some object's array elements or typed array elements.
 class MConstantElements : public MNullaryInstruction
@@ -7151,27 +7156,27 @@ class MConstantElements : public MNullar
     static MConstantElements *New(TempAllocator &alloc, void *v) {
         return new(alloc) MConstantElements(v);
     }
 
     void *value() const {
         return value_;
     }
 
-    void printOpcode(FILE *fp) const;
-
-    HashNumber valueHash() const {
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
+
+    HashNumber valueHash() const MOZ_OVERRIDE {
         return (HashNumber)(size_t) value_;
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return ins->isConstantElements() && ins->toConstantElements()->value() == value();
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
     ALLOW_CLONE(MConstantElements)
 };
 
 // Passes through an object's elements, after ensuring it is entirely doubles.
 class MConvertElementsToDoubles
@@ -7191,20 +7196,20 @@ class MConvertElementsToDoubles
 
     static MConvertElementsToDoubles *New(TempAllocator &alloc, MDefinition *elements) {
         return new(alloc) MConvertElementsToDoubles(elements);
     }
 
     MDefinition *elements() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // This instruction can read and write to the elements' contents.
         // However, it is alright to hoist this from loops which explicitly
         // read or write to the elements: such reads and writes will use double
         // values and can be reordered freely wrt this conversion, except that
         // definite double loads must follow the conversion. The latter
         // property is ensured by chaining this instruction with the elements
         // themselves, in the same manner as MBoundsCheck.
         return AliasSet::None();
@@ -7235,20 +7240,20 @@ class MMaybeToDoubleElement
     }
 
     MDefinition *elements() const {
         return getOperand(0);
     }
     MDefinition *value() const {
         return getOperand(1);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 };
 
 // Passes through an object, after ensuring its elements are not copy on write.
 class MMaybeCopyElementsForWrite
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
@@ -7267,24 +7272,24 @@ class MMaybeCopyElementsForWrite
 
     static MMaybeCopyElementsForWrite *New(TempAllocator &alloc, MDefinition *object) {
         return new(alloc) MMaybeCopyElementsForWrite(object);
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::ObjectFields);
     }
 #ifdef DEBUG
-    bool needsResumePoint() const {
+    bool needsResumePoint() const MOZ_OVERRIDE {
         // This instruction is idempotent and does not change observable
         // behavior, so does not need its own resume point.
         return false;
     }
 #endif
 
 };
 
@@ -7305,24 +7310,24 @@ class MInitializedLength
 
     static MInitializedLength *New(TempAllocator &alloc, MDefinition *elements) {
         return new(alloc) MInitializedLength(elements);
     }
 
     MDefinition *elements() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 
-    void computeRange(TempAllocator &alloc);
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MInitializedLength)
 };
 
 // Store to the initialized length in an elements header. Note the input is an
 // *index*, one less than the desired length.
 class MSetInitializedLength
   : public MAryInstruction<2>,
@@ -7341,17 +7346,17 @@ class MSetInitializedLength
     }
 
     MDefinition *elements() const {
         return getOperand(0);
     }
     MDefinition *index() const {
         return getOperand(1);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::ObjectFields);
     }
 
     ALLOW_CLONE(MSetInitializedLength)
 };
 
 // Load the array length from an elements header.
 class MArrayLength
@@ -7370,24 +7375,24 @@ class MArrayLength
 
     static MArrayLength *New(TempAllocator &alloc, MDefinition *elements) {
         return new(alloc) MArrayLength(elements);
     }
 
     MDefinition *elements() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 
-    void computeRange(TempAllocator &alloc);
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MArrayLength)
 };
 
 // Store to the length in an elements header. Note the input is an *index*, one
 // less than the desired length.
 class MSetArrayLength
   : public MAryInstruction<2>,
@@ -7406,17 +7411,17 @@ class MSetArrayLength
     }
 
     MDefinition *elements() const {
         return getOperand(0);
     }
     MDefinition *index() const {
         return getOperand(1);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::ObjectFields);
     }
 };
 
 // Read the length of a typed array.
 class MTypedArrayLength
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
@@ -7433,24 +7438,24 @@ class MTypedArrayLength
 
     static MTypedArrayLength *New(TempAllocator &alloc, MDefinition *obj) {
         return new(alloc) MTypedArrayLength(obj);
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::TypedArrayLength);
     }
 
-    void computeRange(TempAllocator &alloc);
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 };
 
 // Load a typed array's elements vector.
 class MTypedArrayElements
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
     explicit MTypedArrayElements(MDefinition *object)
@@ -7465,20 +7470,20 @@ class MTypedArrayElements
 
     static MTypedArrayElements *New(TempAllocator &alloc, MDefinition *object) {
         return new(alloc) MTypedArrayElements(object);
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 
     ALLOW_CLONE(MTypedArrayElements)
 };
 
 // Load a binary data object's "elements", which is just its opaque
 // binary data space. Eventually this should probably be
@@ -7507,25 +7512,25 @@ class MTypedObjectElements
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
     bool definitelyOutline() const {
         return definitelyOutline_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isTypedObjectElements())
             return false;
         const MTypedObjectElements *other = ins->toTypedObjectElements();
         if (other->definitelyOutline() != definitelyOutline())
             return false;
         return congruentIfOperandsEqual(other);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 };
 
 // Inlined version of the js::SetTypedObjectOffset() intrinsic.
 class MSetTypedObjectOffset
   : public MBinaryInstruction,
     public NoTypePolicy::Data
@@ -7552,17 +7557,17 @@ class MSetTypedObjectOffset
     MDefinition *object() const {
         return getOperand(0);
     }
 
     MDefinition *offset() const {
         return getOperand(1);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // This affects the result of MTypedObjectElements,
         // which is described as a load of ObjectFields.
         return AliasSet::Store(AliasSet::ObjectFields);
     }
 };
 
 // Perform !-operation
 class MNot
@@ -7586,48 +7591,48 @@ class MNot
         return new(alloc) MNot(elements);
     }
     static MNot *NewAsmJS(TempAllocator &alloc, MDefinition *elements) {
         MNot *ins = new(alloc) MNot(elements);
         ins->setResultType(MIRType_Int32);
         return ins;
     }
 
-    INSTRUCTION_HEADER(Not);
+    INSTRUCTION_HEADER(Not)
 
     void cacheOperandMightEmulateUndefined();
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     void markOperandCantEmulateUndefined() {
         operandMightEmulateUndefined_ = false;
     }
     bool operandMightEmulateUndefined() const {
         return operandMightEmulateUndefined_;
     }
     bool operandIsNeverNaN() const {
         return operandIsNeverNaN_;
     }
 
-    virtual AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void collectRangeInfoPreTrunc();
-
-    void trySpecializeFloat32(TempAllocator &alloc);
-    bool isFloat32Commutative() const { return true; }
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool isFloat32Commutative() const MOZ_OVERRIDE { return true; }
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         return true;
     }
 #endif
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Bailout if index + minimum < 0 or index + maximum >= length. The length used
 // in a bounds check must not be negative, or the wrong result may be computed
 // (unsigned comparisons may be used).
 class MBoundsCheck
@@ -7669,29 +7674,29 @@ class MBoundsCheck
         minimum_ = n;
     }
     int32_t maximum() const {
         return maximum_;
     }
     void setMaximum(int32_t n) {
         maximum_ = n;
     }
-    MDefinition *foldsTo(TempAllocator &alloc);
-    bool congruentTo(const MDefinition *ins) const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isBoundsCheck())
             return false;
         const MBoundsCheck *other = ins->toBoundsCheck();
         if (minimum() != other->minimum() || maximum() != other->maximum())
             return false;
         return congruentIfOperandsEqual(other);
     }
-    virtual AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void computeRange(TempAllocator &alloc);
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MBoundsCheck)
 };
 
 // Bailout if index < minimum.
 class MBoundsCheckLower
   : public MUnaryInstruction,
     public NoTypePolicy::Data
@@ -7718,23 +7723,23 @@ class MBoundsCheckLower
         return getOperand(0);
     }
     int32_t minimum() const {
         return minimum_;
     }
     void setMinimum(int32_t n) {
         minimum_ = n;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
     bool fallible() const {
         return fallible_;
     }
-    void collectRangeInfoPreTrunc();
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
 };
 
 // Instructions which access an object's elements can either do so on a
 // definition accessing that elements pointer, or on the object itself, if its
 // elements are inline. In the latter case there must be an offset associated
 // with the access.
 static inline bool
 IsValidElementsType(MDefinition *elements, int32_t offsetAdjustment)
@@ -7793,30 +7798,30 @@ class MLoadElement
         return loadDoubles_;
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
     bool fallible() const {
         return needsHoleCheck();
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isLoadElement())
             return false;
         const MLoadElement *other = ins->toLoadElement();
         if (needsHoleCheck() != other->needsHoleCheck())
             return false;
         if (loadDoubles() != other->loadDoubles())
             return false;
         if (offsetAdjustment() != other->offsetAdjustment())
             return false;
         return congruentIfOperandsEqual(other);
     }
-    MDefinition *foldsTo(TempAllocator &alloc);
-    AliasSet getAliasSet() const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::Element);
     }
 
     ALLOW_CLONE(MLoadElement)
 };
 
 // Load a value from a dense array's element vector. If the index is
 // out-of-bounds, or the indexed slot has a hole, undefined is returned
@@ -7858,30 +7863,30 @@ class MLoadElementHole
         return getOperand(2);
     }
     bool needsNegativeIntCheck() const {
         return needsNegativeIntCheck_;
     }
     bool needsHoleCheck() const {
         return needsHoleCheck_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isLoadElementHole())
             return false;
         const MLoadElementHole *other = ins->toLoadElementHole();
         if (needsHoleCheck() != other->needsHoleCheck())
             return false;
         if (needsNegativeIntCheck() != other->needsNegativeIntCheck())
             return false;
         return congruentIfOperandsEqual(other);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::Element);
     }
-    void collectRangeInfoPreTrunc();
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
 
     ALLOW_CLONE(MLoadElementHole)
 };
 
 class MLoadUnboxedObjectOrNull
   : public MBinaryInstruction,
     public SingleObjectPolicy::Data
 {
@@ -7924,27 +7929,27 @@ class MLoadUnboxedObjectOrNull
         return bailOnNull_;
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
     bool fallible() const {
         return bailOnNull();
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isLoadUnboxedObjectOrNull())
             return false;
         const MLoadUnboxedObjectOrNull *other = ins->toLoadUnboxedObjectOrNull();
         if (bailOnNull() != other->bailOnNull())
             return false;
         if (offsetAdjustment() != other->offsetAdjustment())
             return false;
         return congruentIfOperandsEqual(other);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::Element);
     }
 
     ALLOW_CLONE(MLoadUnboxedObjectOrNull)
 };
 
 class MLoadUnboxedString
   : public MBinaryInstruction,
@@ -7974,25 +7979,25 @@ class MLoadUnboxedString
         return getOperand(0);
     }
     MDefinition *index() const {
         return getOperand(1);
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isLoadUnboxedString())
             return false;
         const MLoadUnboxedString *other = ins->toLoadUnboxedString();
         if (offsetAdjustment() != other->offsetAdjustment())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::Element);
     }
 
     ALLOW_CLONE(MLoadUnboxedString)
 };
 
 class MStoreElementCommon
 {
@@ -8061,17 +8066,17 @@ class MStoreElement
         return getOperand(0);
     }
     MDefinition *index() const {
         return getOperand(1);
     }
     MDefinition *value() const {
         return getOperand(2);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::Element);
     }
     bool needsHoleCheck() const {
         return needsHoleCheck_;
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
@@ -8116,17 +8121,17 @@ class MStoreElementHole
         return getOperand(1);
     }
     MDefinition *index() const {
         return getOperand(2);
     }
     MDefinition *value() const {
         return getOperand(3);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // StoreElementHole can update the initialized length, the array length
         // or reallocate obj->elements.
         return AliasSet::Store(AliasSet::Element | AliasSet::ObjectFields);
     }
 
     ALLOW_CLONE(MStoreElementHole)
 };
 
@@ -8171,17 +8176,17 @@ class MStoreUnboxedObjectOrNull
         return getOperand(2);
     }
     MDefinition *typedObj() const {
         return getOperand(3);
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // Use AliasSet::Element for reference typed object fields.
         return AliasSet::Store(AliasSet::Element);
     }
 
     // For StoreUnboxedObjectOrNullPolicy.
     void setValue(MDefinition *def) {
         replaceOperand(2, def);
     }
@@ -8222,17 +8227,17 @@ class MStoreUnboxedString
         return getOperand(1);
     }
     MDefinition *value() const {
         return getOperand(2);
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // Use AliasSet::Element for reference typed object fields.
         return AliasSet::Store(AliasSet::Element);
     }
 
     ALLOW_CLONE(MStoreUnboxedString)
 };
 
 // Array.prototype.pop or Array.prototype.shift on a dense array.
@@ -8272,17 +8277,17 @@ class MArrayPopShift
         return needsHoleCheck_;
     }
     bool maybeUndefined() const {
         return maybeUndefined_;
     }
     bool mode() const {
         return mode_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::Element | AliasSet::ObjectFields);
     }
 
     ALLOW_CLONE(MArrayPopShift)
 };
 
 // Array.prototype.push on a dense array. Returns the new array length.
 class MArrayPush
@@ -8303,20 +8308,20 @@ class MArrayPush
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
     MDefinition *value() const {
         return getOperand(1);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::Element | AliasSet::ObjectFields);
     }
-    void computeRange(TempAllocator &alloc);
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MArrayPush)
 };
 
 // Array.prototype.concat on two dense arrays.
 class MArrayConcat
   : public MBinaryInstruction,
     public MixPolicy<ObjectPolicy<0>, ObjectPolicy<1> >::Data
@@ -8347,20 +8352,20 @@ class MArrayConcat
     ArrayObject *templateObj() const {
         return templateObj_;
     }
 
     gc::InitialHeap initialHeap() const {
         return initialHeap_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::Element | AliasSet::ObjectFields);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MArrayJoin
     : public MBinaryInstruction,
       public MixPolicy<ObjectPolicy<0>, StringPolicy<1> >::Data
 {
@@ -8376,23 +8381,23 @@ class MArrayJoin
         return new (alloc) MArrayJoin(array, sep);
     }
     MDefinition *array() const {
         return getOperand(0);
     }
     MDefinition *sep() const {
         return getOperand(1);
     }
-    bool possiblyCalls() const {
-        return true;
-    }
-    virtual AliasSet getAliasSet() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
+        return true;
+    }
+    virtual AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::Element | AliasSet::ObjectFields);
     }
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 };
 
 // See comments above MMemoryBarrier, below.
 
 enum MemoryBarrierRequirement
 {
     DoesNotRequireMemoryBarrier,
     DoesRequireMemoryBarrier
@@ -8452,42 +8457,42 @@ class MLoadTypedArrayElement
         return getOperand(0);
     }
     MDefinition *index() const {
         return getOperand(1);
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // When a barrier is needed make the instruction effectful by
         // giving it a "store" effect.
         if (requiresBarrier_)
             return AliasSet::Store(AliasSet::TypedArrayElement);
         return AliasSet::Load(AliasSet::TypedArrayElement);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (requiresBarrier_)
             return false;
         if (!ins->isLoadTypedArrayElement())
             return false;
         const MLoadTypedArrayElement *other = ins->toLoadTypedArrayElement();
         if (arrayType_ != other->arrayType_)
             return false;
         if (offsetAdjustment() != other->offsetAdjustment())
             return false;
         return congruentIfOperandsEqual(other);
     }
 
-    void printOpcode(FILE *fp) const;
-
-    void computeRange(TempAllocator &alloc);
-
-    bool canProduceFloat32() const { return arrayType_ == Scalar::Float32; }
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
+
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool canProduceFloat32() const MOZ_OVERRIDE { return arrayType_ == Scalar::Float32; }
 
     ALLOW_CLONE(MLoadTypedArrayElement)
 };
 
 // Load a value from a typed array. Out-of-bounds accesses are handled in-line.
 class MLoadTypedArrayElementHole
   : public MBinaryInstruction,
     public SingleObjectPolicy::Data
@@ -8523,30 +8528,30 @@ class MLoadTypedArrayElementHole
         return arrayType_ == Scalar::Uint32 && !allowDouble_;
     }
     MDefinition *object() const {
         return getOperand(0);
     }
     MDefinition *index() const {
         return getOperand(1);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isLoadTypedArrayElementHole())
             return false;
         const MLoadTypedArrayElementHole *other = ins->toLoadTypedArrayElementHole();
         if (arrayType() != other->arrayType())
             return false;
         if (allowDouble() != other->allowDouble())
             return false;
         return congruentIfOperandsEqual(other);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::TypedArrayElement);
     }
-    bool canProduceFloat32() const { return arrayType_ == Scalar::Float32; }
+    bool canProduceFloat32() const MOZ_OVERRIDE { return arrayType_ == Scalar::Float32; }
 
     ALLOW_CLONE(MLoadTypedArrayElementHole)
 };
 
 // Load a value fallibly or infallibly from a statically known typed array.
 class MLoadTypedArrayElementStatic
   : public MUnaryInstruction,
     public ConvertToInt32Policy<0>::Data
@@ -8569,17 +8574,17 @@ class MLoadTypedArrayElementStatic
     // An offset to be encoded in the load instruction - taking advantage of the
     // addressing modes. This is only non-zero when the access is proven to be
     // within bounds.
     int32_t offset_;
     bool needsBoundsCheck_;
     bool fallible_;
 
   public:
-    INSTRUCTION_HEADER(LoadTypedArrayElementStatic);
+    INSTRUCTION_HEADER(LoadTypedArrayElementStatic)
 
     static MLoadTypedArrayElementStatic *New(TempAllocator &alloc, JSObject *someTypedArray,
                                              MDefinition *ptr, int32_t offset = 0,
                                              bool needsBoundsCheck = true)
     {
         return new(alloc) MLoadTypedArrayElementStatic(someTypedArray, ptr, offset,
                                                        needsBoundsCheck);
     }
@@ -8588,36 +8593,36 @@ class MLoadTypedArrayElementStatic
         return AnyTypedArrayType(someTypedArray_);
     }
     void *base() const;
     size_t length() const;
 
     MDefinition *ptr() const { return getOperand(0); }
     int32_t offset() const { return offset_; }
     void setOffset(int32_t offset) { offset_ = offset; }
-    bool congruentTo(const MDefinition *ins) const;
-    AliasSet getAliasSet() const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::TypedArrayElement);
     }
 
     bool needsBoundsCheck() const { return needsBoundsCheck_; }
     void setNeedsBoundsCheck(bool v) { needsBoundsCheck_ = v; }
 
     bool fallible() const {
         return fallible_;
     }
 
     void setInfallible() {
         fallible_ = false;
     }
 
-    void computeRange(TempAllocator &alloc);
-    bool needTruncation(TruncateKind kind);
-    bool canProduceFloat32() const { return viewType() == Scalar::Float32; }
-    void collectRangeInfoPreTrunc();
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool needTruncation(TruncateKind kind) MOZ_OVERRIDE;
+    bool canProduceFloat32() const MOZ_OVERRIDE { return viewType() == Scalar::Float32; }
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
 };
 
 class MStoreTypedArrayElement
   : public MTernaryInstruction,
     public StoreTypedArrayPolicy::Data
 {
     Scalar::Type arrayType_;
     bool requiresBarrier_;
@@ -8672,34 +8677,34 @@ class MStoreTypedArrayElement
         return getOperand(0);
     }
     MDefinition *index() const {
         return getOperand(1);
     }
     MDefinition *value() const {
         return getOperand(2);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::TypedArrayElement);
     }
     bool requiresMemoryBarrier() const {
         return requiresBarrier_;
     }
     int32_t offsetAdjustment() const {
         return offsetAdjustment_;
     }
     bool racy() const {
         return racy_;
     }
     void setRacy() {
         racy_ = true;
     }
-    TruncateKind operandTruncateKind(size_t index) const;
-
-    bool canConsumeFloat32(MUse *use) const {
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
+
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE {
         return use == getUseFor(2) && arrayType_ == Scalar::Float32;
     }
 
     ALLOW_CLONE(MStoreTypedArrayElement)
 };
 
 class MStoreTypedArrayElementHole
   : public MAryInstruction<4>,
@@ -8751,22 +8756,22 @@ class MStoreTypedArrayElementHole
         return getOperand(1);
     }
     MDefinition *index() const {
         return getOperand(2);
     }
     MDefinition *value() const {
         return getOperand(3);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::TypedArrayElement);
     }
-    TruncateKind operandTruncateKind(size_t index) const;
-
-    bool canConsumeFloat32(MUse *use) const {
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
+
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE {
         return use == getUseFor(3) && arrayType_ == Scalar::Float32;
     }
 
     ALLOW_CLONE(MStoreTypedArrayElementHole)
 };
 
 // Store a value infallibly to a statically known typed array.
 class MStoreTypedArrayElementStatic :
@@ -8782,17 +8787,17 @@ class MStoreTypedArrayElementStatic :
     AlwaysTenured<JSObject*> someTypedArray_;
     // An offset to be encoded in the store instruction - taking advantage of the
     // addressing modes. This is only non-zero when the access is proven to be
     // within bounds.
     int32_t offset_;
     bool needsBoundsCheck_;
 
   public:
-    INSTRUCTION_HEADER(StoreTypedArrayElementStatic);
+    INSTRUCTION_HEADER(StoreTypedArrayElementStatic)
 
     static MStoreTypedArrayElementStatic *New(TempAllocator &alloc, JSObject *someTypedArray,
                                               MDefinition *ptr, MDefinition *v,
                                               int32_t offset = 0,
                                               bool needsBoundsCheck = true)
     {
         return new(alloc) MStoreTypedArrayElementStatic(someTypedArray, ptr, v,
                                                         offset, needsBoundsCheck);
@@ -8810,25 +8815,25 @@ class MStoreTypedArrayElementStatic :
     size_t length() const;
 
     MDefinition *ptr() const { return getOperand(0); }
     MDefinition *value() const { return getOperand(1); }
     bool needsBoundsCheck() const { return needsBoundsCheck_; }
     void setNeedsBoundsCheck(bool v) { needsBoundsCheck_ = v; }
     int32_t offset() const { return offset_; }
     void setOffset(int32_t offset) { offset_ = offset; }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::TypedArrayElement);
     }
-    TruncateKind operandTruncateKind(size_t index) const;
-
-    bool canConsumeFloat32(MUse *use) const {
+    TruncateKind operandTruncateKind(size_t index) const MOZ_OVERRIDE;
+
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE {
         return use == getUseFor(1) && viewType() == Scalar::Float32;
     }
-    void collectRangeInfoPreTrunc();
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
 };
 
 // Compute an "effective address", i.e., a compound computation of the form:
 //   base + index * scale + displacement
 class MEffectiveAddress
   : public MBinaryInstruction,
     public NoTypePolicy::Data
 {
@@ -8840,17 +8845,17 @@ class MEffectiveAddress
         setMovable();
         setResultType(MIRType_Int32);
     }
 
     Scale scale_;
     int32_t displacement_;
 
   public:
-    INSTRUCTION_HEADER(EffectiveAddress);
+    INSTRUCTION_HEADER(EffectiveAddress)
 
     static MEffectiveAddress *New(TempAllocator &alloc, MDefinition *base, MDefinition *index,
                                   Scale s, int32_t d)
     {
         return new(alloc) MEffectiveAddress(base, index, s, d);
     }
     MDefinition *base() const {
         return lhs();
@@ -8882,25 +8887,25 @@ class MClampToUint8
 
   public:
     INSTRUCTION_HEADER(ClampToUint8)
 
     static MClampToUint8 *New(TempAllocator &alloc, MDefinition *input) {
         return new(alloc) MClampToUint8(input);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-
-    bool congruentTo(const MDefinition *ins) const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    void computeRange(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MClampToUint8)
 };
 
 class MLoadFixedSlot
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
@@ -8922,31 +8927,31 @@ class MLoadFixedSlot
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
     size_t slot() const {
         return slot_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isLoadFixedSlot())
             return false;
         if (slot() != ins->toLoadFixedSlot()->slot())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-
-    AliasSet getAliasSet() const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::FixedSlot);
     }
 
-    bool mightAlias(const MDefinition *store) const;
+    bool mightAlias(const MDefinition *store) const MOZ_OVERRIDE;
 
     ALLOW_CLONE(MLoadFixedSlot)
 };
 
 class MStoreFixedSlot
   : public MBinaryInstruction,
     public MixPolicy<SingleObjectPolicy, NoFloatPolicy<1> >::Data
 {
@@ -8978,17 +8983,17 @@ class MStoreFixedSlot
     }
     MDefinition *value() const {
         return getOperand(1);
     }
     size_t slot() const {
         return slot_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::FixedSlot);
     }
     bool needsBarrier() const {
         return needsBarrier_;
     }
     void setNeedsBarrier(bool needsBarrier = true) {
         needsBarrier_ = needsBarrier;
     }
@@ -9138,37 +9143,37 @@ class MGetPropertyCache
     }
     bool monitoredResult() const {
         return monitoredResult_;
     }
     CacheLocationList &location() {
         return location_;
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!idempotent_)
             return false;
         if (!ins->isGetPropertyCache())
             return false;
         if (name() != ins->toGetPropertyCache()->name())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         if (idempotent_) {
             return AliasSet::Load(AliasSet::ObjectFields |
                                   AliasSet::FixedSlot |
                                   AliasSet::DynamicSlot);
         }
         return AliasSet::Store(AliasSet::Any);
     }
 
-    void setBlock(MBasicBlock *block);
-    bool updateForReplacement(MDefinition *ins);
+    void setBlock(MBasicBlock *block) MOZ_OVERRIDE;
+    bool updateForReplacement(MDefinition *ins) MOZ_OVERRIDE;
 };
 
 // Emit code to load a value from an object's slots if its shape matches
 // one of the shapes observed by the baseline IC, else bails out.
 class MGetPropertyPolymorphic
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
@@ -9199,17 +9204,17 @@ class MGetPropertyPolymorphic
 
   public:
     INSTRUCTION_HEADER(GetPropertyPolymorphic)
 
     static MGetPropertyPolymorphic *New(TempAllocator &alloc, MDefinition *obj, PropertyName *name) {
         return new(alloc) MGetPropertyPolymorphic(alloc, obj, name);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isGetPropertyPolymorphic())
             return false;
         if (name() != ins->toGetPropertyPolymorphic()->name())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 
     bool addShape(Shape *objShape, Shape *shape) {
@@ -9225,21 +9230,21 @@ class MGetPropertyPolymorphic
         return shapes_[i].objShape;
     }
     Shape *shape(size_t i) const {
         return shapes_[i].shape;
     }
     MDefinition *obj() const {
         return getOperand(0);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields | AliasSet::FixedSlot | AliasSet::DynamicSlot);
     }
 
-    bool mightAlias(const MDefinition *store) const;
+    bool mightAlias(const MDefinition *store) const MOZ_OVERRIDE;
 };
 
 // Emit code to store a value to an object's slots if its shape matches
 // one of the shapes observed by the baseline IC, else bails out.
 class MSetPropertyPolymorphic
   : public MBinaryInstruction,
     public SingleObjectPolicy::Data
 {
@@ -9290,17 +9295,17 @@ class MSetPropertyPolymorphic
         return getOperand(1);
     }
     bool needsBarrier() const {
         return needsBarrier_;
     }
     void setNeedsBarrier() {
         needsBarrier_ = true;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::ObjectFields | AliasSet::FixedSlot | AliasSet::DynamicSlot);
     }
 };
 
 class MDispatchInstruction
   : public MControlInstruction,
     public SingleObjectPolicy::Data
 {
@@ -9555,26 +9560,26 @@ class MGuardShape
         return getOperand(0);
     }
     const Shape *shape() const {
         return shape_;
     }
     BailoutKind bailoutKind() const {
         return bailoutKind_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isGuardShape())
             return false;
         if (shape() != ins->toGuardShape()->shape())
             return false;
         if (bailoutKind() != ins->toGuardShape()->bailoutKind())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 };
 
 // Bail if the object's shape is not one of the shapes in shapes_.
 class MGuardShapePolymorphic
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
@@ -9605,19 +9610,19 @@ class MGuardShapePolymorphic
     }
     size_t numShapes() const {
         return shapes_.length();
     }
     Shape *getShape(size_t i) const {
         return shapes_[i];
     }
 
-    bool congruentTo(const MDefinition *ins) const;
-
-    AliasSet getAliasSet() const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
+
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 };
 
 // Guard on an object's type, inclusively or exclusively.
 class MGuardObjectType
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
@@ -9647,26 +9652,26 @@ class MGuardObjectType
         return getOperand(0);
     }
     const types::TypeObject *typeObject() const {
         return typeObject_;
     }
     bool bailOnEquality() const {
         return bailOnEquality_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isGuardObjectType())
             return false;
         if (typeObject() != ins->toGuardObjectType()->typeObject())
             return false;
         if (bailOnEquality() != ins->toGuardObjectType()->bailOnEquality())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 };
 
 // Guard on an object's identity, inclusively or exclusively.
 class MGuardObjectIdentity
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
@@ -9696,26 +9701,26 @@ class MGuardObjectIdentity
         return getOperand(0);
     }
     JSObject *singleObject() const {
         return singleObject_;
     }
     bool bailOnEquality() const {
         return bailOnEquality_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isGuardObjectIdentity())
             return false;
         if (singleObject() != ins->toGuardObjectIdentity()->singleObject())
             return false;
         if (bailOnEquality() != ins->toGuardObjectIdentity()->bailOnEquality())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 };
 
 // Guard on an object's class.
 class MGuardClass
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
@@ -9738,24 +9743,24 @@ class MGuardClass
     }
 
     MDefinition *obj() const {
         return getOperand(0);
     }
     const Class *getClass() const {
         return class_;
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isGuardClass())
             return false;
         if (getClass() != ins->toGuardClass()->getClass())
             return false;
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::ObjectFields);
     }
 
     ALLOW_CLONE(MGuardClass)
 };
 
 // Load from vp[slot] (slots that are not inline in an object).
 class MLoadSlot
@@ -9782,32 +9787,32 @@ class MLoadSlot
 
     MDefinition *slots() const {
         return getOperand(0);
     }
     uint32_t slot() const {
         return slot_;
     }
 
-    HashNumber valueHash() const;
-    bool congruentTo(const MDefinition *ins) const {
+    HashNumber valueHash() const MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isLoadSlot())
             return false;
         if (slot() != ins->toLoadSlot()->slot())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
-
-    AliasSet getAliasSet() const {
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         MOZ_ASSERT(slots()->type() == MIRType_Slots);
         return AliasSet::Load(AliasSet::DynamicSlot);
     }
-    bool mightAlias(const MDefinition *store) const;
+    bool mightAlias(const MDefinition *store) const MOZ_OVERRIDE;
 
     ALLOW_CLONE(MLoadSlot)
 };
 
 // Inline call to access a function's environment (scope chain).
 class MFunctionEnvironment
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
@@ -9825,20 +9830,20 @@ class MFunctionEnvironment
     static MFunctionEnvironment *New(TempAllocator &alloc, MDefinition *function) {
         return new(alloc) MFunctionEnvironment(function);
     }
 
     MDefinition *function() const {
         return getOperand(0);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     // A function's environment is fixed.
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // Store to vp[slot] (slots that are not inline in an object).
 class MStoreSlot
   : public MBinaryInstruction,
     public MixPolicy<ObjectPolicy<0>, NoFloatPolicy<1> >::Data
@@ -9887,17 +9892,17 @@ class MStoreSlot
         slotType_ = slotType;
     }
     bool needsBarrier() const {
         return needsBarrier_;
     }
     void setNeedsBarrier() {
         needsBarrier_ = true;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::DynamicSlot);
     }
 
     ALLOW_CLONE(MStoreSlot)
 };
 
 class MGetNameCache
   : public MUnaryInstruction,
@@ -9954,20 +9959,20 @@ class MCallGetIntrinsicValue : public MN
     INSTRUCTION_HEADER(CallGetIntrinsicValue)
 
     static MCallGetIntrinsicValue *New(TempAllocator &alloc, PropertyName *name) {
         return new(alloc) MCallGetIntrinsicValue(name);
     }
     PropertyName *name() const {
         return name_;
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool possiblyCalls() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MCallsiteCloneCache
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
@@ -9976,30 +9981,30 @@ class MCallsiteCloneCache
     MCallsiteCloneCache(MDefinition *callee, jsbytecode *callPc)
       : MUnaryInstruction(callee),
         callPc_(callPc)
     {
         setResultType(MIRType_Object);
     }
 
   public:
-    INSTRUCTION_HEADER(CallsiteCloneCache);
+    INSTRUCTION_HEADER(CallsiteCloneCache)
 
     static MCallsiteCloneCache *New(TempAllocator &alloc, MDefinition *callee, jsbytecode *callPc) {
         return new(alloc) MCallsiteCloneCache(callee, callPc);
     }
     MDefinition *callee() const {
         return getOperand(0);
     }
     jsbytecode *callPc() const {
         return callPc_;
     }
 
     // Callsite cloning is idempotent.
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MSetPropertyInstruction : public MBinaryInstruction
 {
     AlwaysTenuredPropertyName name_;
     bool strict_;
@@ -10141,17 +10146,17 @@ class MCallSetProperty
     INSTRUCTION_HEADER(CallSetProperty)
 
     static MCallSetProperty *New(TempAllocator &alloc, MDefinition *obj, MDefinition *value,
                                  PropertyName *name, bool strict)
     {
         return new(alloc) MCallSetProperty(obj, value, name, strict);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MSetPropertyCache
   : public MSetPropertyInstruction,
     public MixPolicy<SingleObjectPolicy, NoFloatPolicy<1> >::Data
 {
@@ -10187,29 +10192,29 @@ class MSetElementCache
     MSetElementCache(MDefinition *obj, MDefinition *index, MDefinition *value, bool strict,
                      bool guardHoles)
       : MSetElementInstruction(obj, index, value, strict),
         guardHoles_(guardHoles)
     {
     }
 
   public:
-    INSTRUCTION_HEADER(SetElementCache);
+    INSTRUCTION_HEADER(SetElementCache)
 
     static MSetElementCache *New(TempAllocator &alloc, MDefinition *obj, MDefinition *index,
                                  MDefinition *value, bool strict, bool guardHoles)
     {
         return new(alloc) MSetElementCache(obj, index, value, strict, guardHoles);
     }
 
     bool guardHoles() const {
         return guardHoles_;
     }
 
-    bool canConsumeFloat32(MUse *use) const { return use == getUseFor(2); }
+    bool canConsumeFloat32(MUse *use) const MOZ_OVERRIDE { return use == getUseFor(2); }
 };
 
 class MCallGetProperty
   : public MUnaryInstruction,
     public BoxInputsPolicy::Data
 {
     AlwaysTenuredPropertyName name_;
     bool idempotent_;
@@ -10242,22 +10247,22 @@ class MCallGetProperty
     }
 
     // Constructors need to perform a GetProp on the function prototype.
     // Since getters cannot be set on the prototype, fetching is non-effectful.
     // The operation may be safely repeated in case of bailout.
     void setIdempotent() {
         idempotent_ = true;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         if (!idempotent_)
             return AliasSet::Store(AliasSet::Any);
         return AliasSet::None();
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // Inline call to handle lhs[rhs]. The first input is a Value so that this
 // instruction can handle both objects and strings.
 class MCallGetElement
   : public MBinaryInstruction,
@@ -10270,17 +10275,17 @@ class MCallGetElement
     }
 
   public:
     INSTRUCTION_HEADER(CallGetElement)
 
     static MCallGetElement *New(TempAllocator &alloc, MDefinition *lhs, MDefinition *rhs) {
         return new(alloc) MCallGetElement(lhs, rhs);
     }
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MCallSetElement
   : public MSetElementInstruction,
     public CallSetElementPolicy::Data
 {
@@ -10293,17 +10298,17 @@ class MCallSetElement
     INSTRUCTION_HEADER(CallSetElement)
 
     static MCallSetElement *New(TempAllocator &alloc, MDefinition *object, MDefinition *index,
                                 MDefinition *value, bool strict)
     {
         return new(alloc) MCallSetElement(object, index, value, strict);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MCallInitElementArray
   : public MAryInstruction<2>,
     public MixPolicy<ObjectPolicy<0>, BoxPolicy<1> >::Data
 {
@@ -10332,17 +10337,17 @@ class MCallInitElementArray
     uint32_t index() const {
         return index_;
     }
 
     MDefinition *value() const {
         return getOperand(1);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MSetDOMProperty
   : public MAryInstruction<2>,
     public MixPolicy<ObjectPolicy<0>, BoxPolicy<1> >::Data
 {
@@ -10372,17 +10377,17 @@ class MSetDOMProperty
         return getOperand(0);
     }
 
     MDefinition *value()
     {
         return getOperand(1);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MGetDOMProperty
   : public MVariadicInstruction,
     public ObjectPolicy<0>::Data
 {
@@ -10469,17 +10474,17 @@ class MGetDOMProperty
     }
     bool valueMayBeInSlot() const {
         return info_->isLazilyCachedInSlot;
     }
     MDefinition *object() {
         return getOperand(0);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isGetDOMProperty())
             return false;
 
         return congruentTo(ins->toGetDOMProperty());
     }
 
     bool congruentTo(const MGetDOMProperty *ins) const {
         if (!isDomMovable())
@@ -10487,27 +10492,27 @@ class MGetDOMProperty
 
         // Checking the jitinfo is the same as checking the constant function
         if (!(info() == ins->info()))
             return false;
 
         return congruentIfOperandsEqual(ins);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         JSJitInfo::AliasSet aliasSet = domAliasSet();
         if (aliasSet == JSJitInfo::AliasNone)
             return AliasSet::None();
         if (aliasSet == JSJitInfo::AliasDOMSets)
             return AliasSet::Load(AliasSet::DOMProperty);
         MOZ_ASSERT(aliasSet == JSJitInfo::AliasEverything);
         return AliasSet::Store(AliasSet::Any);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MGetDOMMember : public MGetDOMProperty
 {
     // We inherit everything from MGetDOMProperty except our
     // possiblyCalls value and the congruentTo behavior.
@@ -10524,21 +10529,21 @@ class MGetDOMMember : public MGetDOMProp
                               MDefinition *guard, MDefinition *globalGuard)
     {
         MGetDOMMember *res = new(alloc) MGetDOMMember(info);
         if (!res || !res->init(alloc, obj, guard, globalGuard))
             return nullptr;
         return res;
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return false;
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isGetDOMMember())
             return false;
 
         return MGetDOMProperty::congruentTo(ins->toGetDOMMember());
     }
 };
 
 class MStringLength
@@ -10553,34 +10558,34 @@ class MStringLength
     }
   public:
     INSTRUCTION_HEADER(StringLength)
 
     static MStringLength *New(TempAllocator &alloc, MDefinition *string) {
         return new(alloc) MStringLength(string);
     }
 
-    MDefinition *foldsTo(TempAllocator &alloc);
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
 
     MDefinition *string() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // The string |length| property is immutable, so there is no
         // implicit dependency.
         return AliasSet::None();
     }
 
-    void computeRange(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MStringLength)
 };
 
 // Inlined version of Math.floor().
 class MFloor
@@ -10597,34 +10602,34 @@ class MFloor
 
   public:
     INSTRUCTION_HEADER(Floor)
 
     static MFloor *New(TempAllocator &alloc, MDefinition *num) {
         return new(alloc) MFloor(num);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool isFloat32Commutative() const {
-        return true;
-    }
-    void trySpecializeFloat32(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool isFloat32Commutative() const MOZ_OVERRIDE {
+        return true;
+    }
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         return true;
     }
 #endif
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    void computeRange(TempAllocator &alloc);
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MFloor)
 };
 
 // Inlined version of Math.ceil().
 class MCeil
@@ -10641,32 +10646,32 @@ class MCeil
 
   public:
     INSTRUCTION_HEADER(Ceil)
 
     static MCeil *New(TempAllocator &alloc, MDefinition *num) {
         return new(alloc) MCeil(num);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool isFloat32Commutative() const {
-        return true;
-    }
-    void trySpecializeFloat32(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool isFloat32Commutative() const MOZ_OVERRIDE {
+        return true;
+    }
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         return true;
     }
 #endif
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    void computeRange(TempAllocator &alloc);
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
 
     ALLOW_CLONE(MCeil)
 };
 
 // Inlined version of Math.round().
 class MRound
   : public MUnaryInstruction,
     public FloatingPointPolicy<0>::Data
@@ -10681,35 +10686,35 @@ class MRound
 
   public:
     INSTRUCTION_HEADER(Round)
 
     static MRound *New(TempAllocator &alloc, MDefinition *num) {
         return new(alloc) MRound(num);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-
-    bool isFloat32Commutative() const {
-        return true;
-    }
-    void trySpecializeFloat32(TempAllocator &alloc);
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+
+    bool isFloat32Commutative() const MOZ_OVERRIDE {
+        return true;
+    }
+    void trySpecializeFloat32(TempAllocator &alloc) MOZ_OVERRIDE;
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         return true;
     }
 #endif
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-    bool canRecoverOnBailout() const {
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 
     ALLOW_CLONE(MRound)
 };
 
 class MIteratorStart
   : public MUnaryInstruction,
@@ -10773,17 +10778,17 @@ class MIsNoIter
 
   public:
     INSTRUCTION_HEADER(IsNoIter)
 
     static MIsNoIter *New(TempAllocator &alloc, MDefinition *def) {
         return new(alloc) MIsNoIter(def);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MIteratorEnd
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
@@ -10816,17 +10821,17 @@ class MIn
 
   public:
     INSTRUCTION_HEADER(In)
 
     static MIn *New(TempAllocator &alloc, MDefinition *key, MDefinition *obj) {
         return new(alloc) MIn(key, obj);
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 
 // Test whether the index is in the array bounds or a hole.
 class MInArray
   : public MQuaternaryInstruction,
@@ -10872,21 +10877,21 @@ class MInArray
         return getOperand(3);
     }
     bool needsHoleCheck() const {
         return needsHoleCheck_;
     }
     bool needsNegativeIntCheck() const {
         return needsNegativeIntCheck_;
     }
-    void collectRangeInfoPreTrunc();
-    AliasSet getAliasSet() const {
+    void collectRangeInfoPreTrunc() MOZ_OVERRIDE;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::Element);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isInArray())
             return false;
         const MInArray *other = ins->toInArray();
         if (needsHoleCheck() != other->needsHoleCheck())
             return false;
         if (needsNegativeIntCheck() != other->needsNegativeIntCheck())
             return false;
         return congruentIfOperandsEqual(other);
@@ -10949,29 +10954,29 @@ class MArgumentsLength : public MNullary
 
   public:
     INSTRUCTION_HEADER(ArgumentsLength)
 
     static MArgumentsLength *New(TempAllocator &alloc) {
         return new(alloc) MArgumentsLength();
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // Arguments |length| cannot be mutated by Ion Code.
         return AliasSet::None();
    }
 
-    void computeRange(TempAllocator &alloc);
-
-    bool writeRecoverData(CompactBufferWriter &writer) const;
-
-    bool canRecoverOnBailout() const {
+    void computeRange(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
+
+    bool canRecoverOnBailout() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 // This MIR instruction is used to get an argument from the actual arguments.
 class MGetFrameArgument
   : public MUnaryInstruction,
     public IntPolicy<0>::Data
@@ -10992,20 +10997,20 @@ class MGetFrameArgument
     static MGetFrameArgument *New(TempAllocator &alloc, MDefinition *idx, bool scriptHasSetArg) {
         return new(alloc) MGetFrameArgument(idx, scriptHasSetArg);
     }
 
     MDefinition *index() const {
         return getOperand(0);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // If the script doesn't have any JSOP_SETARG ops, then this instruction is never
         // aliased.
         if (scriptHasSetArg_)
             return AliasSet::Load(AliasSet::FrameArgument);
         return AliasSet::None();
     }
 };
 
@@ -11033,20 +11038,20 @@ class MSetFrameArgument
     uint32_t argno() const {
         return argno_;
     }
 
     MDefinition *value() const {
         return getOperand(0);
     }
 
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return false;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::FrameArgument);
     }
 };
 
 class MRestCommon
 {
     unsigned numFormals_;
     AlwaysTenured<ArrayObject*> templateObject_;
@@ -11076,33 +11081,33 @@ class MRest
       : MUnaryInstruction(numActuals),
         MRestCommon(numFormals, templateObject)
     {
         setResultType(MIRType_Object);
         setResultTypeSet(MakeSingletonTypeSet(constraints, templateObject));
     }
 
   public:
-    INSTRUCTION_HEADER(Rest);
+    INSTRUCTION_HEADER(Rest)
 
     static MRest *New(TempAllocator &alloc, types::CompilerConstraintList *constraints,
                       MDefinition *numActuals, unsigned numFormals,
                       ArrayObject *templateObject)
     {
         return new(alloc) MRest(constraints, numActuals, numFormals, templateObject);
     }
 
     MDefinition *numActuals() const {
         return getOperand(0);
     }
 
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool possiblyCalls() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MFilterTypeSet
   : public MUnaryInstruction,
     public FilterTypeSetPolicy::Data
 {
@@ -11116,23 +11121,23 @@ class MFilterTypeSet
 
   public:
     INSTRUCTION_HEADER(FilterTypeSet)
 
     static MFilterTypeSet *New(TempAllocator &alloc, MDefinition *def, types::TemporaryTypeSet *types) {
         return new(alloc) MFilterTypeSet(def, types);
     }
 
-    bool congruentTo(const MDefinition *def) const {
+    bool congruentTo(const MDefinition *def) const MOZ_OVERRIDE {
         return false;
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    virtual bool neverHoist() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    virtual bool neverHoist() const MOZ_OVERRIDE {
         return resultTypeSet()->empty();
     }
 };
 
 // Given a value, guard that the value is in a particular TypeSet, then returns
 // that value.
 class MTypeBarrier
   : public MUnaryInstruction,
@@ -11157,23 +11162,23 @@ class MTypeBarrier
   public:
     INSTRUCTION_HEADER(TypeBarrier)
 
     static MTypeBarrier *New(TempAllocator &alloc, MDefinition *def, types::TemporaryTypeSet *types,
                              BarrierKind kind = BarrierKind::TypeSet) {
         return new(alloc) MTypeBarrier(def, types, kind);
     }
 
-    void printOpcode(FILE *fp) const;
-    bool congruentTo(const MDefinition *def) const;
-
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    virtual bool neverHoist() const {
+    void printOpcode(FILE *fp) const MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *def) const MOZ_OVERRIDE;
+
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    virtual bool neverHoist() const MOZ_OVERRIDE {
         return resultTypeSet()->empty();
     }
     BarrierKind barrierKind() const {
         return barrierKind_;
     }
 
     bool alwaysBails() const {
         // If mirtype of input doesn't agree with mirtype of barrier,
@@ -11220,17 +11225,17 @@ class MMonitorTypes
 
     const types::TemporaryTypeSet *typeSet() const {
         return typeSet_;
     }
     BarrierKind barrierKind() const {
         return barrierKind_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // Given a value being written to another object, update the generational store
 // buffer if the value is in the nursery and object is in the tenured heap.
 class MPostWriteBarrier : public MBinaryInstruction, public ObjectPolicy<0>::Data
 {
@@ -11250,22 +11255,22 @@ class MPostWriteBarrier : public MBinary
     MDefinition *object() const {
         return getOperand(0);
     }
 
     MDefinition *value() const {
         return getOperand(1);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 
 #ifdef DEBUG
-    bool isConsistentFloat32Use(MUse *use) const {
+    bool isConsistentFloat32Use(MUse *use) const MOZ_OVERRIDE {
         // During lowering, values that neither have object nor value MIR type
         // are ignored, thus Float32 can show up at this point without any issue.
         return use == getUseFor(1);
     }
 #endif
 
     ALLOW_CLONE(MPostWriteBarrier)
 };
@@ -11277,26 +11282,26 @@ class MNewDeclEnvObject : public MNullar
     explicit MNewDeclEnvObject(DeclEnvObject *templateObj)
       : MNullaryInstruction(),
         templateObj_(templateObj)
     {
         setResultType(MIRType_Object);
     }
 
   public:
-    INSTRUCTION_HEADER(NewDeclEnvObject);
+    INSTRUCTION_HEADER(NewDeclEnvObject)
 
     static MNewDeclEnvObject *New(TempAllocator &alloc, DeclEnvObject *templateObj) {
         return new(alloc) MNewDeclEnvObject(templateObj);
     }
 
     DeclEnvObject *templateObj() {
         return templateObj_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MNewCallObjectBase : public MNullaryInstruction
 {
     AlwaysTenured<CallObject*> templateObj_;
 
@@ -11307,17 +11312,17 @@ class MNewCallObjectBase : public MNulla
     {
         setResultType(MIRType_Object);
     }
 
   public:
     CallObject *templateObject() {
         return templateObj_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MNewCallObject : public MNewCallObjectBase
 {
   public:
     INSTRUCTION_HEADER(NewCallObject)
@@ -11404,17 +11409,17 @@ class MProfilerStackOp : public MNullary
     JSScript *script() {
         return script_;
     }
 
     Type type() {
         return type_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // This is an alias for MLoadFixedSlot.
 class MEnclosingScope : public MLoadFixedSlot
 {
     explicit MEnclosingScope(MDefinition *obj)
@@ -11423,17 +11428,17 @@ class MEnclosingScope : public MLoadFixe
         setResultType(MIRType_Object);
     }
 
   public:
     static MEnclosingScope *New(TempAllocator &alloc, MDefinition *obj) {
         return new(alloc) MEnclosingScope(obj);
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         // ScopeObject reserved slots are immutable.
         return AliasSet::None();
     }
 };
 
 // This is an element of a spaghetti stack which is used to represent the memory
 // context which has to be restored in case of a bailout.
 struct MStoreToRecover : public TempObject, public InlineSpaghettiStackNode<MStoreToRecover>
@@ -11488,40 +11493,40 @@ class MResumePoint MOZ_FINAL :
     // The array may then be filled in by inherit().
     bool init(TempAllocator &alloc);
 
     void clearOperand(size_t index) {
         // FixedList doesn't initialize its elements, so do an unchecked init.
         operands_[index].initUncheckedWithoutProducer(this);
     }
 
-    MUse *getUseFor(size_t index) {
+    MUse *getUseFor(size_t index) MOZ_OVERRIDE {
         return &operands_[index];
     }
-    const MUse *getUseFor(size_t index) const {
+    const MUse *getUseFor(size_t index) const MOZ_OVERRIDE {
         return &operands_[index];
     }
 
   public:
     static MResumePoint *New(TempAllocator &alloc, MBasicBlock *block, jsbytecode *pc,
                              MResumePoint *parent, Mode mode);
     static MResumePoint *New(TempAllocator &alloc, MBasicBlock *block, MResumePoint *model,
                              const MDefinitionVector &operands);
     static MResumePoint *Copy(TempAllocator &alloc, MResumePoint *src);
 
-    MNode::Kind kind() const {
+    MNode::Kind kind() const MOZ_OVERRIDE {
         return MNode::ResumePoint;
     }
     size_t numAllocatedOperands() const {
         return operands_.length();
     }
     uint32_t stackDepth() const {
         return numAllocatedOperands();
     }
-    size_t numOperands() const {
+    size_t numOperands() const MOZ_OVERRIDE {
         return numAllocatedOperands();
     }
     size_t indexOf(const MUse *u) const MOZ_FINAL MOZ_OVERRIDE {
         MOZ_ASSERT(u >= &operands_[0]);
         MOZ_ASSERT(u <= &operands_[numOperands() - 1]);
         return u - &operands_[0];
     }
     void initOperand(size_t index, MDefinition *operand) {
@@ -11531,17 +11536,17 @@ class MResumePoint MOZ_FINAL :
     void replaceOperand(size_t index, MDefinition *operand) MOZ_FINAL MOZ_OVERRIDE {
         operands_[index].replaceProducer(operand);
     }
 
     bool isObservableOperand(MUse *u) const;
     bool isObservableOperand(size_t index) const;
     bool isRecoverableOperand(MUse *u) const;
 
-    MDefinition *getOperand(size_t index) const {
+    MDefinition *getOperand(size_t index) const MOZ_OVERRIDE {
         return operands_[index].producer();
     }
     jsbytecode *pc() const {
         return pc_;
     }
     MResumePoint *caller() const {
         return caller_;
     }
@@ -11576,82 +11581,82 @@ class MResumePoint MOZ_FINAL :
 
     void releaseUses() {
         for (size_t i = 0, e = numOperands(); i < e; i++) {
             if (operands_[i].hasProducer())
                 operands_[i].releaseProducer();
         }
     }
 
-    bool writeRecoverData(CompactBufferWriter &writer) const;
+    bool writeRecoverData(CompactBufferWriter &writer) const MOZ_OVERRIDE;
 
     // Register a store instruction on the current resume point. This
     // instruction would be recovered when we are bailing out. The |cache|
     // argument can be any resume point, it is used to share memory if we are
     // doing the same modification.
     void addStore(TempAllocator &alloc, MDefinition *store, const MResumePoint *cache = nullptr);
 
     MStoresToRecoverList::iterator storesBegin() const {
         return stores_.begin();
     }
     MStoresToRecoverList::iterator storesEnd() const {
         return stores_.end();
     }
 
-    virtual void dump(FILE *fp) const;
-    virtual void dump() const;
+    virtual void dump(FILE *fp) const MOZ_OVERRIDE;
+    virtual void dump() const MOZ_OVERRIDE;
 };
 
 class MIsCallable
   : public MUnaryInstruction,
     public SingleObjectPolicy::Data
 {
     explicit MIsCallable(MDefinition *object)
       : MUnaryInstruction(object)
     {
         setResultType(MIRType_Boolean);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(IsCallable);
+    INSTRUCTION_HEADER(IsCallable)
 
     static MIsCallable *New(TempAllocator &alloc, MDefinition *obj) {
         return new(alloc) MIsCallable(obj);
     }
     MDefinition *object() const {
         return getOperand(0);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MIsObject
   : public MUnaryInstruction,
     public BoxInputsPolicy::Data
 {
     explicit MIsObject(MDefinition *object)
     : MUnaryInstruction(object)
     {
         setResultType(MIRType_Boolean);
         setMovable();
     }
   public:
-    INSTRUCTION_HEADER(IsObject);
+    INSTRUCTION_HEADER(IsObject)
     static MIsObject *New(TempAllocator &alloc, MDefinition *obj) {
         return new(alloc) MIsObject(obj);
     }
     MDefinition *object() const {
         return getOperand(0);
     }
-    bool congruentTo(const MDefinition *ins) const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         return congruentIfOperandsEqual(ins);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 class MHasClass
     : public MUnaryInstruction,
       public SingleObjectPolicy::Data
 {
@@ -11662,32 +11667,32 @@ class MHasClass
       , class_(clasp)
     {
         MOZ_ASSERT(object->type() == MIRType_Object);
         setResultType(MIRType_Boolean);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(HasClass);
+    INSTRUCTION_HEADER(HasClass)
 
     static MHasClass *New(TempAllocator &alloc, MDefinition *obj, const Class *clasp) {
         return new(alloc) MHasClass(obj, clasp);
     }
 
     MDefinition *object() const {
         return getOperand(0);
     }
     const Class *getClass() const {
         return class_;
     }
-    AliasSet getAliasSet() const {
-        return AliasSet::None();
-    }
-    bool congruentTo(const MDefinition *ins) const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
+        return AliasSet::None();
+    }
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE {
         if (!ins->isHasClass())
             return false;
         if (getClass() != ins->toHasClass()->getClass())
             return false;
         return congruentIfOperandsEqual(ins);
     }
 };
 
@@ -11724,17 +11729,17 @@ class MRecompileCheck : public MNullaryI
           default:
             MOZ_CRASH("Unexpected recompile check type");
         }
 
         setGuard();
     }
 
   public:
-    INSTRUCTION_HEADER(RecompileCheck);
+    INSTRUCTION_HEADER(RecompileCheck)
 
     static MRecompileCheck *New(TempAllocator &alloc, JSScript *script_, uint32_t recompileThreshold,
                                 RecompileCheckType type)
     {
         return new(alloc) MRecompileCheck(script_, recompileThreshold, type);
     }
 
     JSScript *script() const {
@@ -11748,17 +11753,17 @@ class MRecompileCheck : public MNullaryI
     bool forceRecompilation() const {
         return forceRecompilation_;
     }
 
     bool increaseWarmUpCounter() const {
         return increaseWarmUpCounter_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::None();
     }
 };
 
 // All barriered operations - MMemoryBarrier, MCompareExchangeTypedArrayElement,
 // and MAtomicTypedArrayElementBinop, as well as MLoadTypedArrayElement and
 // MStoreTypedArrayElement when they are marked as requiring a memory barrer - have
 // the following attributes:
@@ -11782,26 +11787,26 @@ class MMemoryBarrier
     explicit MMemoryBarrier(MemoryBarrierBits type)
       : type_(type)
     {
         MOZ_ASSERT((type_ & ~MembarAllbits) == MembarNobits);
         setGuard();             // Not removable
     }
 
   public:
-    INSTRUCTION_HEADER(MemoryBarrier);
+    INSTRUCTION_HEADER(MemoryBarrier)
 
     static MMemoryBarrier *New(TempAllocator &alloc, MemoryBarrierBits type = MembarFull) {
         return new(alloc) MMemoryBarrier(type);
     }
     MemoryBarrierBits type() const {
         return type_;
     }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::TypedArrayElement);
     }
 };
 
 class MCompareExchangeTypedArrayElement
   : public MAryInstruction<4>,
     public Mix4Policy<ObjectPolicy<0>, IntPolicy<1>, IntPolicy<2>, IntPolicy<3>>::Data
 {
@@ -11815,17 +11820,17 @@ class MCompareExchangeTypedArrayElement
         initOperand(0, elements);
         initOperand(1, index);
         initOperand(2, oldval);
         initOperand(3, newval);
         setGuard();             // Not removable
     }
 
   public:
-    INSTRUCTION_HEADER(CompareExchangeTypedArrayElement);
+    INSTRUCTION_HEADER(CompareExchangeTypedArrayElement)
 
     static MCompareExchangeTypedArrayElement *New(TempAllocator &alloc, MDefinition *elements,
                                                   MDefinition *index, Scalar::Type arrayType,
                                                   MDefinition *oldval, MDefinition *newval)
     {
         return new(alloc) MCompareExchangeTypedArrayElement(elements, index, arrayType, oldval, newval);
     }
     bool isByteArray() const {
@@ -11846,17 +11851,17 @@ class MCompareExchangeTypedArrayElement
         return 2;
     }
     MDefinition *newval() {
         return getOperand(3);
     }
     Scalar::Type arrayType() const {
         return arrayType_;
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::TypedArrayElement);
     }
 };
 
 class MAtomicTypedArrayElementBinop
     : public MAryInstruction<3>,
       public Mix3Policy< ObjectPolicy<0>, IntPolicy<1>, IntPolicy<2> >::Data
 {
@@ -11872,17 +11877,17 @@ class MAtomicTypedArrayElementBinop
     {
         initOperand(0, elements);
         initOperand(1, index);
         initOperand(2, value);
         setGuard();             // Not removable
     }
 
   public:
-    INSTRUCTION_HEADER(AtomicTypedArrayElementBinop);
+    INSTRUCTION_HEADER(AtomicTypedArrayElementBinop)
 
     static MAtomicTypedArrayElementBinop *New(TempAllocator &alloc, AtomicOp op,
                                               MDefinition *elements, MDefinition *index,
                                               Scalar::Type arrayType, MDefinition *value)
     {
         return new(alloc) MAtomicTypedArrayElementBinop(op, elements, index, arrayType, value);
     }
 
@@ -11901,25 +11906,25 @@ class MAtomicTypedArrayElementBinop
         return getOperand(0);
     }
     MDefinition *index() {
         return getOperand(1);
     }
     MDefinition *value() {
         return getOperand(2);
     }
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::TypedArrayElement);
     }
 };
 
 class MDebugger : public MNullaryInstruction
 {
   public:
-    INSTRUCTION_HEADER(Debugger);
+    INSTRUCTION_HEADER(Debugger)
 
     static MDebugger *New(TempAllocator &alloc) {
         return new(alloc) MDebugger();
     }
 };
 
 class MAsmJSNeg
   : public MUnaryInstruction,
@@ -11928,17 +11933,17 @@ class MAsmJSNeg
     MAsmJSNeg(MDefinition *op, MIRType type)
       : MUnaryInstruction(op)
     {
         setResultType(type);
         setMovable();
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSNeg);
+    INSTRUCTION_HEADER(AsmJSNeg)
     static MAsmJSNeg *NewAsmJS(TempAllocator &alloc, MDefinition *op, MIRType type) {
         return new(alloc) MAsmJSNeg(op, type);
     }
 };
 
 class MAsmJSHeapAccess
 {
     Scalar::Type viewType_;
@@ -11997,35 +12002,35 @@ class MAsmJSLoadHeap
             break;
           case Scalar::Uint8Clamped:
           case Scalar::MaxTypedArrayViewType:
             MOZ_CRASH("unexpected uint8clamped load heap in asm.js");
         }
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSLoadHeap);
+    INSTRUCTION_HEADER(AsmJSLoadHeap)
 
     static MAsmJSLoadHeap *New(TempAllocator &alloc, Scalar::Type vt,
                                MDefinition *ptr, bool needsBoundsCheck,
                                MemoryBarrierBits barrierBefore = MembarNobits,
                                MemoryBarrierBits barrierAfter = MembarNobits)
     {
         return new(alloc) MAsmJSLoadHeap(vt, ptr, needsBoundsCheck, barrierBefore, barrierAfter);
     }
 
     MDefinition *ptr() const { return getOperand(0); }
     MemoryBarrierBits barrierBefore() const { return barrierBefore_; }
     MemoryBarrierBits barrierAfter() const { return barrierAfter_; }
 
-    bool congruentTo(const MDefinition *ins) const;
-    AliasSet getAliasSet() const {
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Load(AliasSet::AsmJSHeap);
     }
-    bool mightAlias(const MDefinition *def) const;
+    bool mightAlias(const MDefinition *def) const MOZ_OVERRIDE;
 };
 
 class MAsmJSStoreHeap
   : public MBinaryInstruction,
     public MAsmJSHeapAccess,
     public NoTypePolicy::Data
 {
     MemoryBarrierBits barrierBefore_;
@@ -12038,33 +12043,33 @@ class MAsmJSStoreHeap
         barrierBefore_(before),
         barrierAfter_(after)
     {
         if (before|after)
             setGuard();         // Not removable
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSStoreHeap);
+    INSTRUCTION_HEADER(AsmJSStoreHeap)
 
     static MAsmJSStoreHeap *New(TempAllocator &alloc, Scalar::Type vt,
                                 MDefinition *ptr, MDefinition *v, bool needsBoundsCheck,
                                 MemoryBarrierBits barrierBefore = MembarNobits,
                                 MemoryBarrierBits barrierAfter = MembarNobits)
     {
         return new(alloc) MAsmJSStoreHeap(vt, ptr, v, needsBoundsCheck,
                                           barrierBefore, barrierAfter);
     }
 
     MDefinition *ptr() const { return getOperand(0); }
     MDefinition *value() const { return getOperand(1); }
     MemoryBarrierBits barrierBefore() const { return barrierBefore_; }
     MemoryBarrierBits barrierAfter() const { return barrierAfter_; }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::AsmJSHeap);
     }
 };
 
 class MAsmJSCompareExchangeHeap
   : public MTernaryInstruction,
     public MAsmJSHeapAccess,
     public NoTypePolicy::Data
@@ -12074,30 +12079,30 @@ class MAsmJSCompareExchangeHeap
         : MTernaryInstruction(ptr, oldv, newv),
           MAsmJSHeapAccess(vt, needsBoundsCheck)
     {
         setGuard();             // Not removable
         setResultType(MIRType_Int32);
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSCompareExchangeHeap);
+    INSTRUCTION_HEADER(AsmJSCompareExchangeHeap)
 
     static MAsmJSCompareExchangeHeap *New(TempAllocator &alloc, Scalar::Type vt,
                                           MDefinition *ptr, MDefinition *oldv,
                                           MDefinition *newv, bool needsBoundsCheck)
     {
         return new(alloc) MAsmJSCompareExchangeHeap(vt, ptr, oldv, newv, needsBoundsCheck);
     }
 
     MDefinition *ptr() const { return getOperand(0); }
     MDefinition *oldValue() const { return getOperand(1); }
     MDefinition *newValue() const { return getOperand(2); }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::AsmJSHeap);
     }
 };
 
 class MAsmJSAtomicBinopHeap
   : public MBinaryInstruction,
     public MAsmJSHeapAccess,
     public NoTypePolicy::Data
@@ -12110,29 +12115,29 @@ class MAsmJSAtomicBinopHeap
           MAsmJSHeapAccess(vt, needsBoundsCheck),
           op_(op)
     {
         setGuard();         // Not removable
         setResultType(MIRType_Int32);
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSAtomicBinopHeap);
+    INSTRUCTION_HEADER(AsmJSAtomicBinopHeap)
 
     static MAsmJSAtomicBinopHeap *New(TempAllocator &alloc, AtomicOp op, Scalar::Type vt,
                                       MDefinition *ptr, MDefinition *v, bool needsBoundsCheck)
     {
         return new(alloc) MAsmJSAtomicBinopHeap(op, vt, ptr, v, needsBoundsCheck);
     }
 
     AtomicOp operation() const { return op_; }
     MDefinition *ptr() const { return getOperand(0); }
     MDefinition *value() const { return getOperand(1); }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::AsmJSHeap);
     }
 };
 
 class MAsmJSLoadGlobalVar : public MNullaryInstruction
 {
     MAsmJSLoadGlobalVar(MIRType type, unsigned globalDataOffset, bool isConstant)
       : globalDataOffset_(globalDataOffset), isConstant_(isConstant)
@@ -12141,58 +12146,58 @@ class MAsmJSLoadGlobalVar : public MNull
         setResultType(type);
         setMovable();
     }
 
     unsigned globalDataOffset_;
     bool isConstant_;
 
   public:
-    INSTRUCTION_HEADER(AsmJSLoadGlobalVar);
+    INSTRUCTION_HEADER(AsmJSLoadGlobalVar)
 
     static MAsmJSLoadGlobalVar *New(TempAllocator &alloc, MIRType type, unsigned globalDataOffset,
                                     bool isConstant)
     {
         return new(alloc) MAsmJSLoadGlobalVar(type, globalDataOffset, isConstant);
     }
 
     unsigned globalDataOffset() const { return globalDataOffset_; }
 
-    HashNumber valueHash() const;
-    bool congruentTo(const MDefinition *ins) const;
-    MDefinition *foldsTo(TempAllocator &alloc);
-
-    AliasSet getAliasSet() const {
+    HashNumber valueHash() const MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
+    MDefinition *foldsTo(TempAllocator &alloc) MOZ_OVERRIDE;
+
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return isConstant_ ? AliasSet::None() : AliasSet::Load(AliasSet::AsmJSGlobalVar);
     }
 
-    bool mightAlias(const MDefinition *def) const;
+    bool mightAlias(const MDefinition *def) const MOZ_OVERRIDE;
 };
 
 class MAsmJSStoreGlobalVar
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
     MAsmJSStoreGlobalVar(unsigned globalDataOffset, MDefinition *v)
       : MUnaryInstruction(v), globalDataOffset_(globalDataOffset)
     {}
 
     unsigned globalDataOffset_;
 
   public:
-    INSTRUCTION_HEADER(AsmJSStoreGlobalVar);
+    INSTRUCTION_HEADER(AsmJSStoreGlobalVar)
 
     static MAsmJSStoreGlobalVar *New(TempAllocator &alloc, unsigned globalDataOffset, MDefinition *v) {
         return new(alloc) MAsmJSStoreGlobalVar(globalDataOffset, v);
     }
 
     unsigned globalDataOffset() const { return globalDataOffset_; }
     MDefinition *value() const { return getOperand(0); }
 
-    AliasSet getAliasSet() const {
+    AliasSet getAliasSet() const MOZ_OVERRIDE {
         return AliasSet::Store(AliasSet::AsmJSGlobalVar);
     }
 };
 
 class MAsmJSLoadFuncPtr
   : public MUnaryInstruction,
     public NoTypePolicy::Data
 {
@@ -12200,67 +12205,67 @@ class MAsmJSLoadFuncPtr
       : MUnaryInstruction(index), globalDataOffset_(globalDataOffset)
     {
         setResultType(MIRType_Pointer);
     }
 
     unsigned globalDataOffset_;
 
   public:
-    INSTRUCTION_HEADER(AsmJSLoadFuncPtr);
+    INSTRUCTION_HEADER(AsmJSLoadFuncPtr)
 
     static MAsmJSLoadFuncPtr *New(TempAllocator &alloc, unsigned globalDataOffset,
                                   MDefinition *index)
     {
         return new(alloc) MAsmJSLoadFuncPtr(globalDataOffset, index);
     }
 
     unsigned globalDataOffset() const { return globalDataOffset_; }
     MDefinition *index() const { return getOperand(0); }
 
-    HashNumber valueHash() const;
-    bool congruentTo(const MDefinition *ins) const;
+    HashNumber valueHash() const MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
 };
 
 class MAsmJSLoadFFIFunc : public MNullaryInstruction
 {
     explicit MAsmJSLoadFFIFunc(unsigned globalDataOffset)
       : globalDataOffset_(globalDataOffset)
     {
         setResultType(MIRType_Pointer);
     }
 
     unsigned globalDataOffset_;
 
   public:
-    INSTRUCTION_HEADER(AsmJSLoadFFIFunc);
+    INSTRUCTION_HEADER(AsmJSLoadFFIFunc)
 
     static MAsmJSLoadFFIFunc *New(TempAllocator &alloc, unsigned globalDataOffset)
     {
         return new(alloc) MAsmJSLoadFFIFunc(globalDataOffset);
     }
 
     unsigned globalDataOffset() const { return globalDataOffset_; }
 
-    HashNumber valueHash() const;
-    bool congruentTo(const MDefinition *ins) const;
+    HashNumber valueHash() const MOZ_OVERRIDE;
+    bool congruentTo(const MDefinition *ins) const MOZ_OVERRIDE;
 };
 
 class MAsmJSParameter : public MNullaryInstruction
 {
     ABIArg abi_;
 
     MAsmJSParameter(ABIArg abi, MIRType mirType)
       : abi_(abi)
     {
         setResultType(mirType);
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSParameter);
+    INSTRUCTION_HEADER(AsmJSParameter)
 
     static MAsmJSParameter *New(TempAllocator &alloc, ABIArg abi, MIRType mirType) {
         return new(alloc) MAsmJSParameter(abi, mirType);
     }
 
     ABIArg abi() const { return abi_; }
 };
 
@@ -12268,28 +12273,28 @@ class MAsmJSReturn
   : public MAryControlInstruction<1, 0>,
     public NoTypePolicy::Data
 {
     explicit MAsmJSReturn(MDefinition *ins) {
         initOperand(0, ins);
     }
 
   public:
-    INSTRUCTION_HEADER(AsmJSReturn);
+    INSTRUCTION_HEADER(AsmJSReturn)
     static MAsmJSReturn *New(TempAllocator &alloc, MDefinition *ins) {
         return new(alloc) MAsmJSReturn(ins);
     }
 };
 
 class MAsmJSVoidReturn
   : public MAryControlInstruction<0, 0>,
     public NoTypePolicy::Data
 {
   public:
-    INSTRUCTION_HEADER(AsmJSVoidReturn);
+    INSTRUCTION_HEADER(AsmJSVoidReturn)
     static MAsmJSVoidReturn *New(TempAllocator &alloc) {
         return new(alloc) MAsmJSVoidReturn();
     }
 };
 
 class MAsmJSPassStackArg
   : public MUnaryInstruction,
     public NoTypePolicy::Data
@@ -12297,17 +12302,17 @@ class MAsmJSPassStackArg
     MAsmJSPassStackArg(uint32_t spOffset, MDefinition *ins)
       : MUnaryInstruction(ins),
         spOffset_(spOffset)
     {}
 
     uint32_t spOffset_;
 
   public:
-    INSTRUCTION_HEADER(AsmJSPassStackArg);
+    INSTRUCTION_HEADER(AsmJSPassStackArg)
     static MAsmJSPassStackArg *New(TempAllocator &alloc, uint32_t spOffset, MDefinition *ins) {
         return new(alloc) MAsmJSPassStackArg(spOffset, ins);
     }
     uint32_t spOffset() const {
         return spOffset_;
     }
     void incrementOffset(uint32_t inc) {
         spOffset_ += inc;
@@ -12349,17 +12354,17 @@ class MAsmJSCall MOZ_FINAL
     FixedList<AnyRegister> argRegs_;
     size_t spIncrement_;
 
     MAsmJSCall(const CallSiteDesc &desc, Callee callee, size_t spIncrement)
      : desc_(desc), callee_(callee), spIncrement_(spIncrement)
     { }
 
   public:
-    INSTRUCTION_HEADER(AsmJSCall);
+    INSTRUCTION_HEADER(AsmJSCall)
 
     struct Arg {
         AnyRegister reg;
         MDefinition *def;
         Arg(AnyRegister reg, MDefinition *def) : reg(reg), def(def) {}
     };
     typedef Vector<Arg, 8> Args;
 
@@ -12383,17 +12388,17 @@ class MAsmJSCall MOZ_FINAL
         MOZ_ASSERT(callee_.which() == Callee::Dynamic);
         MOZ_ASSERT(numArgs() == numOperands() - 1);
         return numArgs();
     }
     size_t spIncrement() const {
         return spIncrement_;
     }
 
-    bool possiblyCalls() const {
+    bool possiblyCalls() const MOZ_OVERRIDE {
         return true;
     }
 };
 
 class MUnknownValue : public MNullaryInstruction
 {
   protected:
     MUnknownValue() {
--- a/js/src/jsapi-tests/testChromeBuffer.cpp
+++ b/js/src/jsapi-tests/testChromeBuffer.cpp
@@ -193,16 +193,16 @@ BEGIN_TEST(testChromeBuffer)
         JS::RootedValue arg(cx, JS::ObjectValue(*callTrusted));
         JS::RootedValue rval(cx);
         CHECK(JS_CallFunction(cx, JS::NullPtr(), fun, JS::HandleValueArray(arg), &rval));
         CHECK(rval.toInt32() == 42);
     }
 
     return true;
 }
-virtual void uninit() {
+virtual void uninit() MOZ_OVERRIDE {
     trusted_glob = nullptr;
     trusted_fun = nullptr;
     JS::RemoveObjectRoot(cx, &trusted_glob);
     JS::RemoveObjectRoot(cx, &trusted_fun);
     JSAPITest::uninit();
 }
 END_TEST(testChromeBuffer)
--- a/js/src/jsapi-tests/testGCOutOfMemory.cpp
+++ b/js/src/jsapi-tests/testGCOutOfMemory.cpp
@@ -47,21 +47,21 @@ BEGIN_TEST(testGCOutOfMemory)
          "        --i;"
          "        array.push({});"
          "    }"
          "})();", &root);
     CHECK_EQUAL(errorCount, 1u);
     return true;
 }
 
-virtual JSRuntime * createRuntime() {
+virtual JSRuntime * createRuntime() MOZ_OVERRIDE {
     JSRuntime *rt = JS_NewRuntime(768 * 1024);
     if (!rt)
         return nullptr;
     setNativeStackQuota(rt);
     return rt;
 }
 
-virtual void destroyRuntime() {
+virtual void destroyRuntime() MOZ_OVERRIDE {
     JS_DestroyRuntime(rt);
 }
 
 END_TEST(testGCOutOfMemory)
--- a/js/src/jsapi-tests/testOOM.cpp
+++ b/js/src/jsapi-tests/testOOM.cpp
@@ -12,17 +12,17 @@ BEGIN_TEST(testOOM)
     JS::RootedString jsstr(cx, JS::ToString(cx, v));
     char16_t ch;
     if (!JS_GetStringCharAt(cx, jsstr, 0, &ch))
         return false;
     MOZ_RELEASE_ASSERT(ch == '9');
     return true;
 }
 
-virtual JSRuntime * createRuntime()
+virtual JSRuntime * createRuntime() MOZ_OVERRIDE
 {
     JSRuntime *rt = JS_NewRuntime(0);
     if (!rt)
         return nullptr;
     JS_SetGCParameter(rt, JSGC_MAX_BYTES, (uint32_t)-1);
     setNativeStackQuota(rt);
     return rt;
 }
--- a/js/src/jsapi-tests/tests.h
+++ b/js/src/jsapi-tests/tests.h
@@ -312,36 +312,36 @@ class JSAPITest
     }
 
     virtual JSObject * createGlobal(JSPrincipals *principals = nullptr);
 };
 
 #define BEGIN_TEST(testname)                                            \
     class cls_##testname : public JSAPITest {                           \
       public:                                                           \
-        virtual const char * name() { return #testname; }               \
-        virtual bool run(JS::HandleObject global)
+        virtual const char * name() MOZ_OVERRIDE { return #testname; }  \
+        virtual bool run(JS::HandleObject global) MOZ_OVERRIDE
 
 #define END_TEST(testname)                                              \
     };                                                                  \
     static cls_##testname cls_##testname##_instance;
 
 /*
  * A "fixture" is a subclass of JSAPITest that holds common definitions for a
  * set of tests. Each test that wants to use the fixture should use
  * BEGIN_FIXTURE_TEST and END_FIXTURE_TEST, just as one would use BEGIN_TEST and
  * END_TEST, but include the fixture class as the first argument. The fixture
  * class's declarations are then in scope for the test bodies.
  */
 
 #define BEGIN_FIXTURE_TEST(fixture, testname)                           \
     class cls_##testname : public fixture {                             \
       public:                                                           \
-        virtual const char * name() { return #testname; }               \
-        virtual bool run(JS::HandleObject global)
+        virtual const char * name() MOZ_OVERRIDE { return #testname; }  \
+        virtual bool run(JS::HandleObject global) MOZ_OVERRIDE
 
 #define END_FIXTURE_TEST(fixture, testname)                             \
     };                                                                  \
     static cls_##testname cls_##testname##_instance;
 
 /*
  * A class for creating and managing one temporary file.
  *
--- a/js/src/jsproxy.h
+++ b/js/src/jsproxy.h
@@ -404,17 +404,17 @@ class JS_PUBLIC_API(DirectProxyHandler) 
                              bool *bp) const MOZ_OVERRIDE;
     virtual bool objectClassIs(HandleObject obj, ESClassValue classValue,
                                JSContext *cx) const MOZ_OVERRIDE;
     virtual const char *className(JSContext *cx, HandleObject proxy) const MOZ_OVERRIDE;
     virtual JSString *fun_toString(JSContext *cx, HandleObject proxy,
                                    unsigned indent) const MOZ_OVERRIDE;
     virtual bool regexp_toShared(JSContext *cx, HandleObject proxy,
                                  RegExpGuard *g) const MOZ_OVERRIDE;
-    virtual bool boxedValue_unbox(JSContext *cx, HandleObject proxy, MutableHandleValue vp) const;
+    virtual bool boxedValue_unbox(JSContext *cx, HandleObject proxy, MutableHandleValue vp) const MOZ_OVERRIDE;
     virtual bool isCallable(JSObject *obj) const MOZ_OVERRIDE;
     virtual JSObject *weakmapKeyDelegate(JSObject *proxy) const MOZ_OVERRIDE;
 };
 
 extern JS_FRIEND_DATA(const js::Class* const) ProxyClassPtr;
 
 inline bool IsProxy(JSObject *obj)
 {
--- a/js/src/vm/ScopeObject.cpp
+++ b/js/src/vm/ScopeObject.cpp
@@ -1569,17 +1569,17 @@ class DebugScopeProxy : public BaseProxy
         desc.setAttributes(JSPROP_READONLY | JSPROP_ENUMERATE | JSPROP_PERMANENT);
         desc.value().setObject(*argsObj);
         desc.setGetter(nullptr);
         desc.setSetter(nullptr);
         return true;
     }
 
     bool getOwnPropertyDescriptor(JSContext *cx, HandleObject proxy, HandleId id,
-                                  MutableHandle<PropertyDescriptor> desc) const
+                                  MutableHandle<PropertyDescriptor> desc) const MOZ_OVERRIDE
     {
         Rooted<DebugScopeObject*> debugScope(cx, &proxy->as<DebugScopeObject>());
         Rooted<ScopeObject*> scope(cx, &debugScope->scope());
 
         if (isMissingArguments(cx, id, *scope))
             return getMissingArgumentsPropertyDescriptor(cx, debugScope, *scope, desc);
 
         RootedValue v(cx);
@@ -1727,17 +1727,17 @@ class DebugScopeProxy : public BaseProxy
                                      // Descriptors never store JSNatives for
                                      // accessors: they have either JSFunctions
                                      // or JSPropertyOps.
                                      desc.attributes() | JSPROP_PROPOP_ACCESSORS,
                                      JS_PROPERTYOP_GETTER(desc.getter()),
                                      JS_PROPERTYOP_SETTER(desc.setter()));
     }
 
-    bool ownPropertyKeys(JSContext *cx, HandleObject proxy, AutoIdVector &props) const
+    bool ownPropertyKeys(JSContext *cx, HandleObject proxy, AutoIdVector &props) const MOZ_OVERRIDE
     {
         Rooted<ScopeObject*> scope(cx, &proxy->as<DebugScopeObject>().scope());
 
         if (isMissingArgumentsBinding(*scope)) {
             if (!props.append(NameToId(cx->names().arguments)))
                 return false;
         }